@genkit-ai/anthropic/lib/models.mjs

Genkit AI framework plugin for Anthropic APIs.

import { APIError } from "@anthropic-ai/sdk";
import {
  GenkitError
} from "genkit";
import { modelRef } from "genkit/model";
import { model } from "genkit/plugin";
import { BetaRunner, Runner } from "./runner/index.mjs";
import {
  AnthropicConfigSchema,
  resolveBetaEnabled
} from "./types.mjs";
import { checkModelName, isKnownKey } from "./utils.mjs";
function parseRetryAfterMs(value) {
  if (!value || !value.trim()) return void 0;
  const seconds = Number(value);
  if (!isNaN(seconds) && seconds >= 0) return seconds * 1e3;
  const date = new Date(value);
  if (!isNaN(date.getTime())) return Math.max(0, date.getTime() - Date.now());
  return void 0;
}
const GENERIC_MODEL_INFO = {
  supports: {
    multiturn: true,
    tools: true,
    media: true,
    systemRole: true,
    output: ["text"]
  }
};
const ADVANCED_MODEL_INFO = {
  supports: {
    multiturn: true,
    tools: true,
    media: true,
    systemRole: true,
    output: ["text", "json"],
    constrained: "all"
  }
};
function commonRef(name, info, configSchema = AnthropicConfigSchema) {
  return modelRef({
    name: `anthropic/${name}`,
    configSchema,
    info: info ?? GENERIC_MODEL_INFO
  });
}
const KNOWN_MODELS = {
  "claude-opus-4-7": commonRef("claude-opus-4-7", ADVANCED_MODEL_INFO),
  "claude-opus-4-6": commonRef("claude-opus-4-6", ADVANCED_MODEL_INFO),
  "claude-opus-4-5": commonRef("claude-opus-4-5", ADVANCED_MODEL_INFO),
  "claude-haiku-4-5": commonRef("claude-haiku-4-5", ADVANCED_MODEL_INFO),
  "claude-sonnet-4-6": commonRef("claude-sonnet-4-6", ADVANCED_MODEL_INFO),
  "claude-sonnet-4-5": commonRef("claude-sonnet-4-5", ADVANCED_MODEL_INFO),
  "claude-opus-4-1": commonRef("claude-opus-4-1", ADVANCED_MODEL_INFO),
  "claude-sonnet-4": commonRef("claude-sonnet-4"),
  "claude-opus-4": commonRef("claude-opus-4")
};
function listKnownModels(client, defaultApiVersion) {
  return Object.keys(KNOWN_MODELS).map(
    (name) => claudeModel({ name, client, defaultApiVersion })
  );
}
function claudeRunner(params, configSchema) {
  const { defaultApiVersion, ...runnerParams } = params;
  if (!runnerParams.client) {
    throw new Error("Anthropic client is required to create a runner");
  }
  let stableRunner = null;
  let betaRunner = null;
  return async (request, {
    streamingRequested,
    sendChunk,
    abortSignal
  }) => {
    const normalizedRequest = request;
    const isBeta = resolveBetaEnabled(
      normalizedRequest.config,
      defaultApiVersion
    );
    const runner = isBeta ? betaRunner ??= new BetaRunner(runnerParams) : stableRunner ??= new Runner(runnerParams);
    try {
      return await runner.run(normalizedRequest, {
        streamingRequested,
        sendChunk,
        abortSignal
      });
    } catch (e) {
      if (e instanceof APIError) {
        let status = "UNKNOWN";
        switch (e.status) {
          case 429:
            status = "RESOURCE_EXHAUSTED";
            break;
          case 401:
            status = "UNAUTHENTICATED";
            break;
          case 403:
            status = "PERMISSION_DENIED";
            break;
          case 400:
            status = "INVALID_ARGUMENT";
            break;
          case 500:
            status = "INTERNAL";
            break;
          case 503:
          case 529:
            status = "UNAVAILABLE";
            break;
        }
        const retryAfterHeader = e.headers?.get?.("retry-after");
        const retryAfterMs = retryAfterHeader ? parseRetryAfterMs(retryAfterHeader) : void 0;
        const responseMetadata = retryAfterMs !== void 0 ? { retryAfterMs } : void 0;
        throw new GenkitError({
          status,
          message: e.message,
          responseMetadata
        });
      }
      throw e;
    }
  };
}
function claudeModelReference(name, config = {}) {
  const modelName = checkModelName(name);
  if (isKnownKey(modelName, KNOWN_MODELS)) {
    return KNOWN_MODELS[modelName].withConfig(config);
  }
  return modelRef({
    name: `anthropic/${modelName}`,
    config,
    configSchema: AnthropicConfigSchema,
    info: {
      ...GENERIC_MODEL_INFO
    }
  });
}
function claudeModel(params) {
  const { name, client: runnerClient, defaultApiVersion: apiVersion } = params;
  const ref = claudeModelReference(name);
  return model(
    {
      name: ref.name,
      ...ref.info,
      configSchema: ref.configSchema
    },
    claudeRunner(
      {
        name,
        client: runnerClient,
        defaultApiVersion: apiVersion
      },
      ref.configSchema
    )
  );
}
const TEST_ONLY = { KNOWN_MODELS };
export {
  ADVANCED_MODEL_INFO,
  GENERIC_MODEL_INFO,
  TEST_ONLY,
  claudeModel,
  claudeModelReference,
  claudeRunner,
  listKnownModels
};
//# sourceMappingURL=models.mjs.map