Modellkosten bei wachsendem Volumen planbar halten

const BASE_URL = "https://openapi.felo.ai/api/v1";
const headers = {
  Authorization: `Bearer ${process.env.FELO_API_KEY}`,
  "Content-Type": "application/json",
};

type Completion = {
  choices: { message: { content: string } }[];
  usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
};

async function chat(model: string, prompt: string): Promise<Completion> {
  const res = await fetch(`${BASE_URL}/chat/completions`, {
    method: "POST",
    headers,
    body: JSON.stringify({ model, messages: [{ role: "user", content: prompt }] }),
  });
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  return res.json() as Promise<Completion>;
}

const summary = await chat(
  "claude-haiku-5-5",
  "Summarize this changelog in three bullets: …",
);
console.log(summary.choices[0].message.content);

type TaskKind = "classify" | "extract" | "summarize" | "draft" | "review";

const MODEL_ROUTES: Record<TaskKind, string> = {
  classify: "claude-haiku-5-5",
  extract: "claude-haiku-5-5",
  summarize: "claude-haiku-5-5",
  draft: "claude-sonnet-5-5",
  review: "claude-sonnet-5-5",
};

export async function route(kind: TaskKind, prompt: string) {
  const model = MODEL_ROUTES[kind];
  const result = await chat(model, prompt);
  return {
    model,
    text: result.choices[0].message.content,
    usage: result.usage,
  };
}

type UsageRecord = {
  model: string;
  kind: TaskKind;
  promptTokens: number;
  completionTokens: number;
  totalTokens: number;
};

const usageLog: UsageRecord[] = [];

function logUsage(kind: TaskKind, model: string, usage: Completion["usage"]) {
  const entry: UsageRecord = {
    model,
    kind,
    promptTokens: usage.prompt_tokens,
    completionTokens: usage.completion_tokens,
    totalTokens: usage.total_tokens,
  };
  usageLog.push(entry);
  console.log(JSON.stringify(entry)); // ship this line to your metrics store
  return entry;
}

export function tokensByModel() {
  return usageLog.reduce<Record<string, number>>((totals, entry) => {
    totals[entry.model] = (totals[entry.model] ?? 0) + entry.totalTokens;
    return totals;
  }, {});
}

const result = await route("summarize", "Summarize this changelog in three bullets: …");
logUsage("summarize", result.model, result.usage);
console.log(tokensByModel());

async function chatOnChannel(model: string, prompt: string, channel?: string) {
  const res = await fetch(`${BASE_URL}/chat/completions`, {
    method: "POST",
    headers: {
      ...headers,
      ...(channel ? { "X-Felo-Channel": channel } : {}),
    },
    body: JSON.stringify({ model, messages: [{ role: "user", content: prompt }] }),
  });
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  return res.json() as Promise<Completion>;
}

// Leave `channel` undefined for the default supplier.
export function routePinned(kind: TaskKind, prompt: string, channel?: string) {
  return chatOnChannel(MODEL_ROUTES[kind], prompt, channel);
}

type Catalog = {
  data: { id: string; owned_by: string; model_kind: string }[];
};

export async function chatModelIds() {
  const res = await fetch(
    `${BASE_URL}/models?exclude_video_and_decisions=true`,
    { headers },
  );
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  const catalog = (await res.json()) as Catalog;
  return catalog.data
    .filter((model) => model.model_kind === "chat")
    .map((model) => model.id);
}

// Price `tokensByModel()` against https://openapi.felo.ai/pricing and
// https://openapi.felo.ai/models. Keep the links, not the rates, in your code.