pkgxray 0.1.0

package/src/providers/anthropic.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const DEFAULT_MODEL = "claude-opus-4-7";
+const ENV_KEY = "ANTHROPIC_API_KEY";
+
+function detect(modelId) {
+  return typeof modelId === "string" && modelId.startsWith("claude-");
+}
+
+function loadSdk() {
+  try {
+    const mod = require("@anthropic-ai/sdk");
+    return mod.default || mod;
+  } catch (error) {
+    if (error && error.code === "MODULE_NOT_FOUND") {
+      const hint = new Error(
+        "Anthropic provider needs @anthropic-ai/sdk. Install with: npm install @anthropic-ai/sdk"
+      );
+      hint.code = "REASONER_SDK_MISSING";
+      throw hint;
+    }
+    throw error;
+  }
+}
+
+async function call({ systemPrompt, userMessage, schema, model, apiKey, maxTokens, effort }) {
+  const Anthropic = loadSdk();
+  const client = new Anthropic({ apiKey });
+  const chosenModel = model || DEFAULT_MODEL;
+  const start = Date.now();
+  const response = await client.messages.create({
+    model: chosenModel,
+    max_tokens: maxTokens || 16000,
+    thinking: { type: "adaptive" },
+    output_config: {
+      effort: effort || "high",
+      format: { type: "json_schema", schema }
+    },
+    system: [
+      {
+        type: "text",
+        text: systemPrompt,
+        cache_control: { type: "ephemeral" }
+      }
+    ],
+    messages: [{ role: "user", content: userMessage }]
+  });
+  const latencyMs = Date.now() - start;
+  const textBlock = response.content.find((block) => block.type === "text");
+  if (!textBlock) {
+    const error = new Error("Anthropic response had no text content");
+    error.code = "REASONER_NO_TEXT";
+    throw error;
+  }
+  return {
+    text: textBlock.text,
+    usage: response.usage || null,
+    model: chosenModel,
+    latencyMs,
+    stopReason: response.stop_reason || null
+  };
+}
+
+module.exports = { name: "anthropic", defaultModel: DEFAULT_MODEL, envKey: ENV_KEY, detect, call };

package/src/providers/gemini.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const DEFAULT_MODEL = "gemini-2.5-pro";
+const ENV_KEY = "GEMINI_API_KEY";
+
+function detect(modelId) {
+  return typeof modelId === "string" && /^gemini-/i.test(modelId);
+}
+
+function loadSdk() {
+  try {
+    return require("@google/generative-ai");
+  } catch (error) {
+    if (error && error.code === "MODULE_NOT_FOUND") {
+      const hint = new Error(
+        "Gemini provider needs @google/generative-ai. Install with: npm install @google/generative-ai"
+      );
+      hint.code = "REASONER_SDK_MISSING";
+      throw hint;
+    }
+    throw error;
+  }
+}
+
+async function call({ systemPrompt, userMessage, schema, model, apiKey, maxTokens }) {
+  const { GoogleGenerativeAI } = loadSdk();
+  const genAI = new GoogleGenerativeAI(apiKey || process.env[ENV_KEY] || process.env.GOOGLE_API_KEY);
+  const chosenModel = model || DEFAULT_MODEL;
+  const generative = genAI.getGenerativeModel({
+    model: chosenModel,
+    systemInstruction: systemPrompt,
+    generationConfig: {
+      responseMimeType: "application/json",
+      maxOutputTokens: maxTokens || 16000
+    }
+  });
+  const start = Date.now();
+  const result = await generative.generateContent(userMessage);
+  const latencyMs = Date.now() - start;
+  const response = result.response;
+  const text = typeof response.text === "function" ? response.text() : "";
+  if (!text) {
+    const error = new Error("Gemini response had no text content");
+    error.code = "REASONER_NO_TEXT";
+    throw error;
+  }
+  const meta = response.usageMetadata || {};
+  const usage = {
+    input_tokens: meta.promptTokenCount || 0,
+    output_tokens: meta.candidatesTokenCount || 0,
+    cache_read_input_tokens: meta.cachedContentTokenCount || 0,
+    cache_creation_input_tokens: 0
+  };
+  const finishReason =
+    response.candidates && response.candidates[0] && response.candidates[0].finishReason;
+  return {
+    text,
+    usage,
+    model: chosenModel,
+    latencyMs,
+    stopReason: finishReason || null,
+    schemaHint: schema ? "schema enforced via prompt only on Gemini" : null
+  };
+}
+
+module.exports = { name: "gemini", defaultModel: DEFAULT_MODEL, envKey: ENV_KEY, detect, call };

package/src/providers/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const anthropic = require("./anthropic");
+const openai = require("./openai");
+const gemini = require("./gemini");
+
+const PROVIDERS = { anthropic, openai, gemini };
+
+function listProviders() {
+  return Object.keys(PROVIDERS);
+}
+
+function getProvider(name) {
+  const provider = PROVIDERS[name];
+  if (!provider) {
+    const error = new Error(`Unknown provider: ${name}. Available: ${listProviders().join(", ")}`);
+    error.code = "REASONER_UNKNOWN_PROVIDER";
+    throw error;
+  }
+  return provider;
+}
+
+function detectProvider(modelId) {
+  if (!modelId) return null;
+  for (const provider of Object.values(PROVIDERS)) {
+    if (provider.detect(modelId)) return provider;
+  }
+  return null;
+}
+
+function resolveProvider({ provider, model } = {}) {
+  if (provider) return getProvider(provider);
+  if (model) {
+    const detected = detectProvider(model);
+    if (detected) return detected;
+  }
+  return anthropic;
+}
+
+module.exports = { PROVIDERS, listProviders, getProvider, detectProvider, resolveProvider };

package/src/providers/openai.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const DEFAULT_MODEL = "gpt-5";
+const ENV_KEY = "OPENAI_API_KEY";
+
+function detect(modelId) {
+  if (typeof modelId !== "string") return false;
+  return /^(gpt-|o\d|chatgpt-)/i.test(modelId);
+}
+
+function loadSdk() {
+  try {
+    const mod = require("openai");
+    return mod.default || mod.OpenAI || mod;
+  } catch (error) {
+    if (error && error.code === "MODULE_NOT_FOUND") {
+      const hint = new Error(
+        "OpenAI provider needs the openai package. Install with: npm install openai"
+      );
+      hint.code = "REASONER_SDK_MISSING";
+      throw hint;
+    }
+    throw error;
+  }
+}
+
+async function call({ systemPrompt, userMessage, schema, model, apiKey, maxTokens }) {
+  const OpenAI = loadSdk();
+  const client = new OpenAI({ apiKey });
+  const chosenModel = model || DEFAULT_MODEL;
+  const start = Date.now();
+  const completion = await client.chat.completions.create({
+    model: chosenModel,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ],
+    response_format: {
+      type: "json_schema",
+      json_schema: {
+        name: "supply_chain_verdict",
+        strict: true,
+        schema
+      }
+    },
+    max_completion_tokens: maxTokens || 16000
+  });
+  const latencyMs = Date.now() - start;
+  const choice = completion.choices && completion.choices[0];
+  if (!choice || !choice.message || typeof choice.message.content !== "string") {
+    const error = new Error("OpenAI response had no message content");
+    error.code = "REASONER_NO_TEXT";
+    throw error;
+  }
+  const usage = completion.usage
+    ? {
+        input_tokens: completion.usage.prompt_tokens,
+        output_tokens: completion.usage.completion_tokens,
+        cache_read_input_tokens:
+          (completion.usage.prompt_tokens_details &&
+            completion.usage.prompt_tokens_details.cached_tokens) ||
+          0,
+        cache_creation_input_tokens: 0
+      }
+    : null;
+  return {
+    text: choice.message.content,
+    usage,
+    model: chosenModel,
+    latencyMs,
+    stopReason: choice.finish_reason || null
+  };
+}
+
+module.exports = { name: "openai", defaultModel: DEFAULT_MODEL, envKey: ENV_KEY, detect, call };