@omega.js/extension 0.1.0

package/dist/vendor/devkit/translate/providers.js

@@ -0,0 +1,188 @@
+/**
+ * AI providers for the translation engine — `claude` (default; rides the
+ * locally-installed Claude Code via @anthropic-ai/claude-agent-sdk, so no API
+ * key is needed) and `chatgpt` (OpenAI Responses API via native fetch;
+ * requires OPENAI_API_KEY). Both expose the same contract:
+ *   provider.send({ system, user }) → Promise<{ text, usage }>
+ * where usage is { input, output } token counts (zeros when unreported).
+ *
+ * The Agent SDK is lazy-required, so it is only touched when a claude call
+ * actually happens, and devkit itself stays dependency-free here. It resolves
+ * from whoever installed it: @omega.js/extension declares it, @omega.js/web
+ * does NOT (#37: translation is opt-in and the SDK is heavy, so a web brand
+ * that enables translation installs it in the target). When it is absent, the
+ * call fails loud with the install command instead of skipping translation.
+ */
+
+const PROVIDERS = ['claude', 'chatgpt'];
+
+// Default model per provider. 'sonnet' is the Claude Code alias that tracks
+// the current Sonnet — no stale date pins in framework code.
+const DEFAULT_MODELS = {
+  claude: 'sonnet',
+  chatgpt: 'gpt-5.4-nano',
+};
+
+/**
+ * Build a provider handle from config values.
+ * @param {object} options
+ * @param {string} [options.provider] - 'claude' (default) or 'chatgpt'
+ * @param {string} [options.model] - model override (default per provider)
+ * @param {Function} [options.fetchFn] - fetch override (tests)
+ * @returns {{ name: string, model: string, send: Function }}
+ */
+function resolveProvider(options) {
+  options = options || {};
+  const name = options.provider || 'claude';
+
+  if (!PROVIDERS.includes(name)) {
+    throw new Error(`Unknown translation provider "${name}" — use ${PROVIDERS.map((p) => `'${p}'`).join(' or ')}`);
+  }
+
+  const model = options.model || DEFAULT_MODELS[name];
+  const send = name === 'claude'
+    ? (message) => sendClaude(model, message)
+    : (message) => sendChatgpt(model, message, options.fetchFn);
+
+  return { name, model, send };
+}
+
+/**
+ * Send one prompt through the local Claude Code install (Agent SDK).
+ * @param {string} model - model name/alias
+ * @param {{ system: string, user: string }} message
+ * @returns {Promise<{ text: string, usage: { input: number, output: number } }>}
+ */
+async function sendClaude(model, message) {
+  let query;
+  try {
+    ({ query } = require('@anthropic-ai/claude-agent-sdk'));
+  } catch (e) {
+    throw new Error('The claude translation provider needs @anthropic-ai/claude-agent-sdk, which is not installed here. Translation is opt-in and the SDK is heavy, so the framework does not bundle it: install it in this target with `npm install @anthropic-ai/claude-agent-sdk` (it also needs a local Claude Code install/auth), or set translation.providers to { chatgpt: {} }.');
+  }
+
+  let text = '';
+  const usage = { input: 0, output: 0 };
+
+  // Hermetic single-shot: settingSources [] keeps the user's CLAUDE.md/hooks
+  // out of the session (they pollute mechanical output), the system prompt
+  // replaces the CLI persona, and no maxTurns cap — a plain reply already
+  // counts as the final turn and a cap of 1 reports error_max_turns.
+  //
+  // Subscription-only by contract: this provider rides the local Claude
+  // Code install's own login. A stray ANTHROPIC_API_KEY anywhere in the
+  // env cascade would silently flip the SDK to API-credit billing — the
+  // child env hides it so the subscription is the ONLY auth path.
+  const env = { ...process.env };
+  delete env.ANTHROPIC_API_KEY;
+
+  const consume = async () => {
+    for await (const event of query({
+      prompt: message.user,
+      options: {
+        model,
+        allowedTools: [],
+        settingSources: [],
+        systemPrompt: message.system,
+        env,
+      },
+    })) {
+      if (event.type === 'assistant' && event.message?.content) {
+        for (const block of event.message.content) {
+          if (block.type === 'text') {
+            text += block.text;
+          }
+        }
+      }
+
+      if (event.type === 'result') {
+        // A failed call must throw NOW — a session-limited install can
+        // otherwise stall the whole build (the 28-minute cp119 hang)
+        if (event.subtype && event.subtype !== 'success') {
+          throw new Error(`Claude translate call failed (${event.subtype})${event.result ? `: ${String(event.result).slice(0, 200)}` : ''} — if this is the session limit, wait for the 5-hour window to reset or build with --cached-only.`);
+        }
+        if (event.usage) {
+          usage.input += event.usage.input_tokens || 0;
+          usage.output += event.usage.output_tokens || 0;
+        }
+      }
+    }
+  };
+
+  // Hard per-call ceiling — a stalled SDK call fails loud and fast instead
+  // of hanging the caller (OMEGA_TRANSLATE_TIMEOUT_MS overrides; tests use it)
+  const timeoutMs = Number(process.env.OMEGA_TRANSLATE_TIMEOUT_MS || 240000);
+  let timer = null;
+  try {
+    await Promise.race([
+      consume(),
+      new Promise((resolve, reject) => {
+        // NOT unref'd on purpose: the finally-clearTimeout already stops a
+        // settled call from holding the process, and an unref'd watchdog
+        // lets a stalled SDK call with no other live handles drain the
+        // event loop and exit SILENTLY before the timer can fire — the
+        // exact opposite of failing loud (and a test-run flake: the
+        // stalled-call test was cancelled whenever nothing else kept the
+        // loop alive for the 80ms window).
+        timer = setTimeout(() => reject(new Error(`Claude translate call exceeded ${Math.round(timeoutMs / 1000)}s — a stalled SDK call (often the session limit); wait for the window to reset or build with --cached-only.`)), timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  return { text, usage };
+}
+
+/**
+ * Send one prompt through the OpenAI Responses API.
+ * @param {string} model - model name
+ * @param {{ system: string, user: string }} message
+ * @param {Function} [fetchFn] - fetch override (tests)
+ * @returns {Promise<{ text: string, usage: { input: number, output: number } }>}
+ */
+async function sendChatgpt(model, message, fetchFn) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error('The chatgpt translation provider requires OPENAI_API_KEY in the environment (.env cascade) — or use the default "claude" provider (local Claude Code, no key).');
+  }
+
+  const doFetch = fetchFn || fetch;
+  const response = await doFetch('https://api.openai.com/v1/responses', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    signal: AbortSignal.timeout(240000),
+    body: JSON.stringify({
+      model,
+      input: [
+        { role: 'developer', content: message.system },
+        { role: 'user', content: message.user },
+      ],
+      reasoning: { effort: 'low' },
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => '');
+    throw new Error(`OpenAI API error ${response.status}: ${body.slice(0, 300)}`);
+  }
+
+  const data = await response.json();
+
+  // Reasoning models emit a reasoning item first — find the message item
+  const item = (data.output || []).find((o) => o.type === 'message');
+  const text = item?.content?.[0]?.text || '';
+
+  return {
+    text,
+    usage: {
+      input: data.usage?.input_tokens || 0,
+      output: data.usage?.output_tokens || 0,
+    },
+  };
+}
+
+module.exports = { PROVIDERS, DEFAULT_MODELS, resolveProvider };