Call a workflow from your code

// npm install asteroid-odyssey
import { client, agentExecutePost, executionGet } from 'asteroid-odyssey';

const TERMINAL = ['completed', 'failed', 'cancelled'];
const WAITING_FOR_A_PERSON = ['paused', 'paused_by_agent', 'awaiting_confirmation'];

client.setConfig({
  baseUrl: 'https://odyssey.asteroid.ai/agents/v2',
  headers: { 'X-Asteroid-Agents-Api-Key': process.env.ASTEROID_API_KEY! },
});

async function runAgent(agentId: string, inputs: Record<string, unknown>) {
  const { data, error } = await agentExecutePost({
    path: { agentId },
    body: { inputs },
  });
  if (error) throw new Error(`execute failed: ${JSON.stringify(error)}`);

  const executionId = data!.executionId;
  const deadline = Date.now() + 30 * 60 * 1000;

  while (Date.now() < deadline) {
    await new Promise((resolve) => setTimeout(resolve, 5000));

    const { data: execution, error: pollError } = await executionGet({ path: { executionId } });
    if (pollError) throw new Error(`poll failed: ${JSON.stringify(pollError)}`);
    if (!execution) continue;

    if (TERMINAL.includes(execution.status)) return execution;

    if (WAITING_FOR_A_PERSON.includes(execution.status)) {
      throw new Error(
        `${executionId} waits for a person (${execution.status}): ${execution.platformUrl}`,
      );
    }
  }

  throw new Error(`${executionId} did not finish inside 30 minutes`);
}

const execution = await runAgent(process.env.ASTEROID_AGENT_ID!, {
  patientName: 'Jane Doe',
});

// failed and cancelled runs carry no executionResult.
if (execution.status !== 'completed' || !execution.executionResult) {
  throw new Error(`run ended ${execution.status}: ${execution.platformUrl}`);
}

const { outcome, result, reasoning } = execution.executionResult;

switch (outcome) {
  case 'slots_found':
    console.log(result);
    break;
  case 'no_slots_available':
    console.log(reasoning);
    break;
  default:
    // A new outcome label is a change to the contract. Escalate, do not crash.
    throw new Error(`unhandled outcome "${outcome}": ${execution.platformUrl}`);
}

# pip install --upgrade asteroid-odyssey
import os
import time

from asteroid_odyssey import ApiClient, Configuration
from asteroid_odyssey.api.agents_api import AgentsApi
from asteroid_odyssey.api.execution_api import ExecutionApi
from asteroid_odyssey.models.agents_agent_execute_agent_request import (
    AgentsAgentExecuteAgentRequest,
)

TERMINAL = ("completed", "failed", "cancelled")
WAITING_FOR_A_PERSON = ("paused", "paused_by_agent", "awaiting_confirmation")

config = Configuration(api_key={"ApiKeyAuth": os.environ["ASTEROID_API_KEY"]})


def run_agent(agent_id: str, inputs: dict):
    with ApiClient(config) as api_client:
        agents_api = AgentsApi(api_client)
        execution_api = ExecutionApi(api_client)

        response = agents_api.agent_execute_post(
            agent_id=agent_id,
            agents_agent_execute_agent_request=AgentsAgentExecuteAgentRequest(
                inputs=inputs,
            ),
        )
        execution_id = response.execution_id
        deadline = time.time() + 30 * 60

        while time.time() < deadline:
            time.sleep(5)
            execution = execution_api.execution_get(execution_id=execution_id)

            if execution.status in TERMINAL:
                return execution

            if execution.status in WAITING_FOR_A_PERSON:
                raise RuntimeError(
                    f"{execution_id} waits for a person "
                    f"({execution.status}): {execution.platform_url}"
                )

        raise TimeoutError(f"{execution_id} did not finish inside 30 minutes")


execution = run_agent(os.environ["ASTEROID_AGENT_ID"], {"patientName": "Jane Doe"})

# failed and cancelled runs carry no execution_result.
if execution.status != "completed" or execution.execution_result is None:
    raise RuntimeError(f"run ended {execution.status}: {execution.platform_url}")

outcome = execution.execution_result.outcome

if outcome == "slots_found":
    print(execution.execution_result.result)
elif outcome == "no_slots_available":
    print(execution.execution_result.reasoning)
else:
    # A new outcome label is a change to the contract. Escalate, do not crash.
    raise RuntimeError(f'unhandled outcome "{outcome}": {execution.platform_url}')

#!/usr/bin/env bash
# Needs curl and jq.
set -euo pipefail

BASE="https://odyssey.asteroid.ai/agents/v2"
AUTH="X-Asteroid-Agents-Api-Key: $ASTEROID_API_KEY"

# 1. Start the run.
EXECUTION_ID=$(curl -sS --fail-with-body -X POST "$BASE/agents/$ASTEROID_AGENT_ID/execute" \
  -H "$AUTH" \
  -H "Content-Type: application/json" \
  -d '{"inputs": {"patientName": "Jane Doe"}}' | jq -r .executionId)

echo "started $EXECUTION_ID"

# 2. Poll every 5 seconds until the status is terminal. 360 tries = 30 minutes.
EXECUTION=""
for _ in $(seq 1 360); do
  sleep 5
  EXECUTION=$(curl -sS --fail-with-body "$BASE/executions/$EXECUTION_ID" -H "$AUTH")
  STATUS=$(echo "$EXECUTION" | jq -r .status)
  echo "status: $STATUS"

  case "$STATUS" in
    completed|failed|cancelled)
      break
      ;;
    paused|paused_by_agent|awaiting_confirmation)
      echo "waits for a person: $(echo "$EXECUTION" | jq -r .platformUrl)" >&2
      exit 1
      ;;
  esac
done

case "$STATUS" in
  completed|failed|cancelled) ;;
  *)
    echo "$EXECUTION_ID did not finish inside 30 minutes (status: $STATUS)" >&2
    exit 1
    ;;
esac

# 3. Read the result.
echo "$EXECUTION" | jq '{
  status,
  outcome: .executionResult.outcome,
  reasoning: .executionResult.reasoning,
  result: .executionResult.result,
  url: .platformUrl
}'

curl -X POST "https://odyssey.asteroid.ai/agents/v2/executions/$EXECUTION_ID/user-messages" \
  -H "X-Asteroid-Agents-Api-Key: $ASTEROID_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "Confirmed. Book the 09:00 slot."}'

import { executionUserMessagesAdd } from 'asteroid-odyssey';

await executionUserMessagesAdd({
  path: { executionId },
  body: { message: 'Confirmed. Book the 09:00 slot.' },
});

execution_api.execution_user_messages_add(
    execution_id=execution_id,
    agents_execution_user_messages_add_text_body={
        "message": "Confirmed. Book the 09:00 slot."
    },
)