TradAI API Reference¶

import type { ErrorResponse } from './types/backend';

async function submitBacktest(config: BacktestConfig) {
  const { data, error } = await client.POST('/api/v1/backtests', { body: config });

  if (error) {
    const errorCode = error.detail?.code;

    switch (errorCode) {
      case 'VAL001':
        throw new Error('Please select a valid date range');
      case 'AUTH001':
        await refreshToken();
        return submitBacktest(config); // Retry
      case 'SVC003':
      case 'SVC004':
        await delay(5000);
        return submitBacktest(config); // Retry with backoff
      default:
        throw new Error(`API Error: ${error.detail?.message || 'Unknown error'}`);
    }
  }

  return data;
}

// 1. Start optimization
const { data: job } = await client.POST('/api/v1/hyperopt', {
  body: {
    strategy: 'TrendFollowingStrategy',
    n_trials: 100,
    objective_metric: 'sharpe_ratio'
  }
});

// 2. Poll for progress
let status = 'running';
while (status === 'running') {
  const { data } = await client.GET('/api/v1/hyperopt/{job_id}', {
    params: { path: { job_id: job.job_id } }
  });
  status = data.status;
  console.log(`Progress: ${data.current_trial}/${data.total_trials}`);
  await delay(5000);
}

// 3. Get best parameters
const { data: result } = await client.GET('/api/v1/hyperopt/{job_id}/result', {
  params: { path: { job_id: job.job_id } }
});
console.log('Best params:', result.best_params);

import createClient from 'openapi-fetch';
import type { paths } from './types/backend';

// Create client with default configuration
const client = createClient<paths>({
  baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
  headers: {
    'Content-Type': 'application/json',
  },
});

// Add authentication interceptor
client.use({
  async onRequest({ request }) {
    const token = await getAuthToken();
    if (token) {
      request.headers.set('Authorization', `Bearer ${token}`);
    }
    return request;
  },
  async onResponse({ response }) {
    // Extract correlation ID for debugging
    const correlationId = response.headers.get('X-Correlation-ID');
    if (correlationId) {
      console.debug(`Request ${correlationId}`);
    }
    return response;
  },
});

// Type-safe API calls
const { data, error } = await client.POST('/api/v1/backtests', {
  body: {
    config: {
      strategy: 'TrendFollowingStrategy',
      pairs: ['BTC/USDT:USDT'],
      timeframe: '1h',
      date_range: {
        start: '2024-01-01T00:00:00Z',
        end: '2024-03-01T00:00:00Z',
      },
      stake_amount: 100.0,
      dry_run_wallet: 10000.0,
    },
    experiment_name: 'my-backtest',
    priority: 5,
  },
});

if (error) {
  console.error('Failed:', error.detail);
  return;
}

console.log('Job ID:', data.job_id);

import type { ErrorDetail } from './types/backend';

// Retry configuration
const MAX_RETRIES = 3;
const RETRY_DELAY = 1000;

async function withRetry<T>(
  fn: () => Promise<{ data?: T; error?: { detail: ErrorDetail } }>,
  retries = MAX_RETRIES
): Promise<T> {
  const { data, error } = await fn();

  if (error) {
    const code = error.detail?.code;

    // Non-retryable errors
    if (code?.startsWith('VAL') || code?.startsWith('AUTH')) {
      throw new ApiError(error.detail);
    }

    // Retryable service errors
    if (code?.startsWith('SVC') && retries > 0) {
      await delay(RETRY_DELAY * (MAX_RETRIES - retries + 1));
      return withRetry(fn, retries - 1);
    }

    throw new ApiError(error.detail);
  }

  return data!;
}

// Usage
try {
  const result = await withRetry(() =>
    client.POST('/api/v1/backtests', { body: config })
  );
  console.log('Created:', result.job_id);
} catch (e) {
  if (e instanceof ApiError) {
    handleApiError(e);
  }
}

// Generic paginated fetcher
async function* fetchPaginated<T>(
  endpoint: string,
  params?: Record<string, unknown>
): AsyncGenerator<T, void, unknown> {
  let cursor: string | null = null;

  do {
    const { data, error } = await client.GET(endpoint, {
      params: {
        query: { ...params, cursor, limit: 50 },
      },
    });

    if (error) throw new ApiError(error.detail);

    for (const item of data.items) {
      yield item as T;
    }

    cursor = data.next_cursor;
  } while (cursor);
}

// Usage: Iterate all backtests
for await (const backtest of fetchPaginated('/api/v1/backtests')) {
  console.log(backtest.job_id, backtest.status);
}

// Or collect all into array
async function getAllBacktests(status?: string) {
  const results = [];
  for await (const bt of fetchPaginated('/api/v1/backtests', { status })) {
    results.push(bt);
  }
  return results;
}

interface PollOptions {
  interval?: number;
  timeout?: number;
  onProgress?: (status: string) => void;
}

async function pollBacktest(
  jobId: string,
  options: PollOptions = {}
): Promise<BacktestResult> {
  const { interval = 5000, timeout = 600000, onProgress } = options;
  const startTime = Date.now();

  while (Date.now() - startTime < timeout) {
    const { data, error } = await client.GET('/api/v1/backtests/{job_id}', {
      params: { path: { job_id: jobId } },
    });

    if (error) throw new ApiError(error.detail);

    onProgress?.(data.status);

    if (data.status === 'completed') {
      return data.result;
    }

    if (data.status === 'failed') {
      throw new Error(`Backtest failed: ${data.error}`);
    }

    if (data.status === 'cancelled') {
      throw new Error('Backtest was cancelled');
    }

    await delay(interval);
  }

  throw new Error(`Polling timeout after ${timeout}ms`);
}

// Usage
const result = await pollBacktest(jobId, {
  interval: 3000,
  timeout: 300000,
  onProgress: (status) => console.log(`Status: ${status}`),
});

import createClient from 'openapi-fetch';
import type { paths, components } from './types/backend';

type BacktestConfig = components['schemas']['BacktestConfig'];
type BacktestResult = components['schemas']['BacktestResult'];

const client = createClient<paths>({
  baseUrl: 'http://localhost:8000',
});

async function runBacktest(config: BacktestConfig): Promise<BacktestResult> {
  // 1. Submit backtest
  const { data: job, error: submitError } = await client.POST('/api/v1/backtests', {
    body: {
      config,
      experiment_name: `backtest-${Date.now()}`,
      priority: 5,
    },
  });

  if (submitError) {
    throw new Error(`Submit failed: ${submitError.detail}`);
  }

  console.log(`Job submitted: ${job.job_id}`);

  // 2. Poll until complete
  const result = await pollBacktest(job.job_id, {
    onProgress: (status) => console.log(`[${job.job_id}] ${status}`),
  });

  // 3. Get equity curve
  const { data: equity } = await client.GET('/api/v1/backtests/{job_id}/equity', {
    params: { path: { job_id: job.job_id } },
  });

  return { ...result, equity };
}

// Run it
const result = await runBacktest({
  strategy: 'TrendFollowingStrategy',
  pairs: ['BTC/USDT:USDT', 'ETH/USDT:USDT'],
  timeframe: '1h',
  date_range: {
    start: '2024-01-01T00:00:00Z',
    end: '2024-06-01T00:00:00Z',
  },
  stake_amount: 100,
  dry_run_wallet: 10000,
});

console.log(`Sharpe: ${result.sharpe_ratio}, Profit: ${result.total_profit_pct}%`);