TypeScript SDK

npm install @infery/sdk

import Infery from '@infery/sdk';

const client = new Infery({ apiKey: process.env.INFERY_API_KEY! });

const chat = await client.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Say hello in one line.' }],
});

console.log(chat.choices[0]?.message?.content);

for await (const chunk of client.chat.completions.stream({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Write a haiku about the sea.' }],
})) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

// `modality` is exactly what GET /v1/models reports as `_infery.modality`,
// so it can come straight off a model you looked up.
const result = await client.media.generate({
  modality: 'video',          // 'image' | 'video' | 'audio' | 'music' | 'object_3d' | 'upscale'
  model: 'veo-3.1',
  prompt: 'a drone shot over a coastline',
  duration: 8,                // model-specific params pass straight through
});

console.log(result.artifacts[0]?.url);

async function make(job: { modality: MediaModality; model: string; prompt: string }) {
  const result = await client.media.generate(job);
  return result.artifacts.map((a) => a.url ?? a.b64 ?? a.bytes);
}

await client.media.generate(
  { modality: 'video', model: 'veo-3.1', prompt: 'a reef' },
  { onProgress: (p) => console.log(p.status, p.progress) },
);

const started = await client.media.generate(
  { modality: 'image', model: 'flux-pro', prompt: 'a topographic map' },
  { background: true },
);

// `modality` is required here too: video jobs and every other modality's jobs
// live at different endpoints, and a job id does not say which it is.
const done = await client.media.wait({ modality: 'image', jobId: started.jobId! });

interface MediaResult {
  modality: MediaModality;
  artifacts: MediaArtifact[];
  created?: number;
  creditsUsed?: number;
  jobId?: string;            // background: true only
  artifactsExpired?: boolean;
  raw: unknown;              // the untouched per-modality payload
}

// Waits, and collects the result if the gateway defers. Either way you get an image.
const image = await client.images.generate({ model: 'dall-e-3', prompt: 'an isometric dashboard' });
console.log(image.data[0]?.url);

const deferred = await client.images.generate(
  { model: 'flux-pro', prompt: 'a topographic map' },
  { background: true },
);

if (deferred.job_id) {
  const job = await client.jobs.wait(deferred.job_id, { intervalMs: 5_000 });
  console.log(job.data?.[0]?.url);
}

const video = await client.videos.generate({ model: 'veo-3', prompt: 'a drone shot over a coastline' });
// A finished video carries its file on `result`, not on `data[]`.
console.log(video.result?.url);

const run = await client.workflows.runs.create({
  pipeline_id: 'wf_abc123',
  input: { topic: 'quarterly summary' },
});

for await (const event of client.workflows.runs.stream({ pipeline_id: 'wf_abc123', input: {} })) {
  switch (event.type) {
    case 'step.started':
      console.log('running', event.stepId);
      break;
    case 'step.completed':
      console.log('done', event.stepId, event.creditsUsed);
      break;
    case 'pipeline.completed':
      console.log('total', event.creditsUsed);
      break;
  }
}

import { APIError, InsufficientCreditsError, ConflictError } from '@infery/sdk';

try {
  await client.chat.completions.create({ model: 'gpt-4o', messages });
} catch (err) {
  if (err instanceof InsufficientCreditsError) {
    // 403 with a balance shortfall — top up, do not retry.
  } else if (err instanceof ConflictError && err.code === 'upload_in_progress') {
    // Retry in a moment.
  } else if (err instanceof APIError) {
    console.error(err.status, err.code, err.requestId);
  } else {
    throw err;
  }
}

const controller = new AbortController();
setTimeout(() => controller.abort(), 10_000);

const models = await client.models.list({ timeout: 5_000 });
const answer = await client.chat.completions.create(
  { model: 'gpt-4o', messages },
  { signal: controller.signal, timeout: 30_000 },
);