@combycode/llm-sdk 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -46,10 +46,10 @@ export type { AudioFormat, AudioOptions, AudioInput } from './llm/types/audio';
 export { contentParts, contentText } from './llm/types/messages';
 export type { Role, MessageOrigin, ContentPart, TextPart, ImagePart, DocumentPart, AudioPart, VideoPart, ToolCallPart, ToolResultPart, ImageOutputPart, AudioOutputPart, VideoOutputPart, MediaOutputPart, DataSource, Content, Message } from './llm/types/messages';
 export { isFunctionTool, isBuiltinTool } from './llm/types/tools';
-export type { FunctionTool, BuiltinTool, Tool, ToolChoice, JsonSchema } from './llm/types/tools';
+export type { FunctionTool, BuiltinTool, McpToolParams, Tool, ToolChoice, JsonSchema } from './llm/types/tools';
 export { emptyUsage } from './llm/types/response';
-export type { CompletionResponse, FinishReason, Usage } from './llm/types/response';
-export type { NormalizedRequest, ThinkingConfig, CacheConfig } from './llm/types/request';
+export type { CompletionResponse, FileOutput, FinishReason, Usage } from './llm/types/response';
+export type { NormalizedRequest, ReasoningContext, ThinkingConfig, CacheConfig } from './llm/types/request';
 export type { MediaStreamType, StreamEvent } from './llm/types/stream';
 export type { ExecuteOptions } from './llm/types/options';
 export type { ProviderName, ApiType, ProviderConfig, ProviderHttpRequest, ProviderAdapter } from './llm/types/provider';
@@ -247,6 +247,7 @@ export { embed } from './helpers/embed';
 export type { EmbedOptions } from './helpers/embed';
 export { moderate } from './helpers/moderate';
 export type { ModerateOptions, ModerationCategories, ModerationContentPart, ModerationImageUrlPart, ModerationResult, ModerationScores, ModerationTextPart } from './helpers/moderate-types';
+export type { ModerationEntry, ModerationReport, ModerationRequest, ModerationStreamOptions, ModerationStreamStrategy } from './llm/moderation/types';
 export { listModels, listModelsLive, clearLiveModelsCache } from './helpers/models';
 export type { ListModelsLiveOptions } from './helpers/models';
 export { select, selectModels } from './helpers/select-model';

package/dist/index.js

@@ -22104,6 +22104,7 @@ var ModelCatalog = class {
       family: info.family,
       version: info.version,
       status: info.status,
+      availability: info.availability,
       active: info.active,
       deprecation: info.deprecation
     });
@@ -22191,6 +22192,168 @@ var ModelCatalog = class {
   }
 };
 
+// src/llm/providers/openai/moderations.ts
+var OPENAI_MODERATION_BASE_URL = "https://api.openai.com";
+var OPENAI_MODERATION_PATH = "/v1/moderations";
+var OPENAI_MODERATION_DEFAULT_MODEL = "omni-moderation-latest";
+var OpenAIModerationAdapter = class {
+  apiKey;
+  baseURL;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL ?? OPENAI_MODERATION_BASE_URL;
+  }
+  async moderate(input, model, fetch2) {
+    const res = await fetch2({
+      url: `${this.baseURL}${OPENAI_MODERATION_PATH}`,
+      method: "POST",
+      headers: { authorization: `Bearer ${this.apiKey}`, "content-type": "application/json" },
+      body: { model, input },
+      provider: "openai",
+      model,
+      responseType: "json"
+    });
+    if (res.status >= 400) {
+      throw new Error(`OpenAI moderations failed (${res.status}): ${JSON.stringify(res.body)}`);
+    }
+    const data = res.body;
+    return (data.results ?? []).map(parseRawResult);
+  }
+};
+function parseRawResult(r) {
+  return {
+    flagged: r.flagged,
+    categories: r.categories,
+    categoryScores: r.category_scores,
+    categoryAppliedInputTypes: r.category_applied_input_types
+  };
+}
+
+// src/llm/moderation/types.ts
+var MODERATION_DEFAULT_MODEL = "omni-moderation-latest";
+var MODERATION_DEFAULT_STRATEGY = "buffer";
+var MODERATION_DEFAULT_INTERVAL = 400;
+
+// src/llm/moderation/runner.ts
+function resolveModerationMode(provider, mod) {
+  if (mod.mode) return mod.mode;
+  return provider === "openai" ? "native" : "emulate";
+}
+function moderationInputText(messages) {
+  const lastUser = [...messages].reverse().find((m) => m.role === "user");
+  if (!lastUser) return "";
+  return typeof lastUser.content === "string" ? lastUser.content : contentText(lastUser.content);
+}
+function emptyResult() {
+  return {
+    flagged: false,
+    categories: {},
+    categoryScores: {}
+  };
+}
+async function runModeration(text, cfg) {
+  if (!text) return emptyResult();
+  try {
+    const adapter = new OpenAIModerationAdapter({ apiKey: cfg.apiKey });
+    const results = await adapter.moderate(text, cfg.model, cfg.fetch);
+    return results[0] ?? emptyResult();
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+}
+function moderationModel(mod) {
+  return mod.model ?? MODERATION_DEFAULT_MODEL;
+}
+function emitModerationZeroCost(hooks, model) {
+  const entry = {
+    id: crypto.randomUUID(),
+    timestamp: Date.now(),
+    provider: "openai",
+    model,
+    tokens: { input: 0, output: 0, cached: 0, cacheWrite: 0, reasoning: 0 },
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, total: 0, source: "calculated" },
+    providerEvidence: { note: "free: moderations endpoint not billed" },
+    tags: { provider: "openai", model, type: "moderation" }
+  };
+  hooks.emitSync("onCostEntry", { entry, runningTotal: 0 });
+}
+function outputEvent(result) {
+  return { type: "moderation", phase: "output", result, source: "emulated" };
+}
+function wrapModeratedStream(raw, strategy, interval, moderate2) {
+  const step = interval > 0 ? interval : MODERATION_DEFAULT_INTERVAL;
+  if (strategy === "post") return wrapPost(raw, moderate2);
+  if (strategy === "parallel") return wrapParallel(raw, step, moderate2);
+  return wrapBuffer(raw, step, moderate2);
+}
+async function* wrapPost(raw, moderate2) {
+  let acc = "";
+  for await (const ev of raw) {
+    if (ev.type === "text") acc += ev.text;
+    yield ev;
+  }
+  if (acc) yield outputEvent(await moderate2(acc));
+}
+async function* wrapBuffer(raw, interval, moderate2) {
+  let acc = "";
+  let checkedAt = 0;
+  let hold = [];
+  for await (const ev of raw) {
+    hold.push(ev);
+    if (ev.type === "text") {
+      acc += ev.text;
+      if (acc.length - checkedAt >= interval || ev.text.includes("\n")) {
+        checkedAt = acc.length;
+        yield outputEvent(await moderate2(acc));
+        for (const h of hold) yield h;
+        hold = [];
+      }
+    }
+  }
+  if (acc.length > checkedAt) yield outputEvent(await moderate2(acc));
+  for (const h of hold) yield h;
+}
+async function* wrapParallel(raw, interval, moderate2) {
+  const iter = raw[Symbol.asyncIterator]();
+  const pending = /* @__PURE__ */ new Set();
+  let acc = "";
+  let checkedAt = 0;
+  let rawDone = false;
+  let rawNext = iter.next();
+  const schedule = (text) => {
+    const p = moderate2(text).then((result) => {
+      pending.delete(p);
+      return { tag: "mod", event: outputEvent(result) };
+    });
+    pending.add(p);
+  };
+  while (!rawDone || pending.size > 0) {
+    const racers = [];
+    if (!rawDone) racers.push(rawNext.then((result) => ({ tag: "raw", result })));
+    for (const p of pending) racers.push(p);
+    const winner = await Promise.race(racers);
+    if (winner.tag === "mod") {
+      yield winner.event;
+      continue;
+    }
+    if (winner.result.done) {
+      rawDone = true;
+      if (acc.length > checkedAt) schedule(acc);
+      continue;
+    }
+    const ev = winner.result.value;
+    yield ev;
+    if (ev.type === "text") {
+      acc += ev.text;
+      if (acc.length - checkedAt >= interval) {
+        checkedAt = acc.length;
+        schedule(acc);
+      }
+    }
+    rawNext = iter.next();
+  }
+}
+
 // src/util/duration.ts
 var UNIT_MS = {
   s: 1e3,
@@ -22327,6 +22490,7 @@ var LLMClient = class {
   mode;
   batchable;
   adapter;
+  apiKey;
   fetchFn;
   fetchStreamFn;
   priority;
@@ -22350,6 +22514,7 @@ var LLMClient = class {
     this.provider = config.provider;
     this.model = config.model;
     this.system = config.system;
+    this.apiKey = config.apiKey;
     this.hooks = config.hooks ?? new HookBus();
     this.fetchFn = config.fetch;
     this.fetchStreamFn = config.fetchStream ?? null;
@@ -22403,6 +22568,34 @@ var LLMClient = class {
       }
     };
   }
+  // ─── Moderation helpers ───────────────────────────────────────────────
+  /** Resolve the OpenAI key the emulated moderation path needs. Reuses the
+   *  client's own key when the provider is OpenAI; otherwise requires an explicit
+   *  one. Throws when none is resolvable (report-only feature, but the call still
+   *  needs a key to reach the moderations endpoint). */
+  resolveModerationKey(mod) {
+    const key = mod.apiKey ?? (this.provider === "openai" ? this.apiKey : void 0);
+    if (!key) {
+      throw new Error(
+        "moderation: emulated moderation requires an OpenAI API key (the only public moderations endpoint). Pass moderation.apiKey, or use the OpenAI provider."
+      );
+    }
+    return key;
+  }
+  moderationConfig(mod) {
+    return {
+      apiKey: this.resolveModerationKey(mod),
+      model: moderationModel(mod),
+      fetch: this.fetchFn
+    };
+  }
+  /** Fold a moderation stream event into the accumulating report. */
+  mergeModeration(prev, phase, result, source) {
+    const next = prev && prev.source === source ? { ...prev } : { source };
+    if (phase === "input") next.input = result;
+    else next.output = result;
+    return next;
+  }
   /** Submit a request. Returns the parsed CompletionResponse. */
   async complete(input, options = {}) {
     const rawMessages = normalizeInput(input);
@@ -22423,6 +22616,7 @@ var LLMClient = class {
       thinking: options.thinking,
       cache: options.cache,
       serviceTier: options.serviceTier,
+      moderation: options.moderation,
       providerOptions: options.providerOptions,
       audio: options.audio,
       outputModalities: options.outputModalities,
@@ -22478,6 +22672,8 @@ var LLMClient = class {
     await this.hooks.emit("onBeforeSubmit", submitCtx);
     const inputChars = JSON.stringify(normalized.messages).length;
     const estimatedInputTokens = Math.ceil(inputChars / 4);
+    const mod = options.moderation;
+    const moderationCfg = mod && resolveModerationMode(this.provider, mod) === "emulate" ? this.moderationConfig(mod) : void 0;
     const start = performance.now();
     let response;
     if (submitCtx.intercepted && submitCtx.resultPromise) {
@@ -22503,6 +22699,22 @@ var LLMClient = class {
     }
     const latencyMs = performance.now() - start;
     const result = this.adapter.parseResponse(response.body, latencyMs);
+    if (mod && moderationCfg) {
+      const cfg = moderationCfg;
+      const doInput = mod.input ?? true;
+      const doOutput = mod.output ?? true;
+      const [inputEntry, outputEntry] = await Promise.all([
+        doInput ? runModeration(moderationInputText(normalized.messages), cfg) : Promise.resolve(void 0),
+        doOutput ? runModeration(result.text, cfg) : Promise.resolve(void 0)
+      ]);
+      if (doInput) emitModerationZeroCost(this.hooks, cfg.model);
+      if (doOutput) emitModerationZeroCost(this.hooks, cfg.model);
+      result.moderation = {
+        source: "emulated",
+        ...inputEntry ? { input: inputEntry } : {},
+        ...outputEntry ? { output: outputEntry } : {}
+      };
+    }
     await this.hooks.emit("onCompletion", {
       provider: this.provider,
       model: this.model,
@@ -22550,6 +22762,7 @@ var LLMClient = class {
       thinking: options.thinking,
       cache: options.cache,
       serviceTier: options.serviceTier,
+      moderation: options.moderation,
       providerOptions: options.providerOptions,
       audio: options.audio,
       outputModalities: options.outputModalities,
@@ -22593,29 +22806,65 @@ var LLMClient = class {
     let thinking = "";
     let usage = emptyUsage();
     let finishReason = "stop";
-    for await (const sseEvent of this.fetchStreamFn(httpReq, {
-      queueName: this.queueName,
-      priority: this.priority,
-      ctx
-    })) {
-      const events = this.adapter.parseStreamEvent(sseEvent);
-      for (const event of events) {
-        switch (event.type) {
-          case "text":
-            text += event.text;
-            break;
-          case "thinking":
-            thinking += event.text;
-            break;
-          case "usage":
-            usage = event.usage;
-            break;
-          case "done":
-            finishReason = event.finishReason;
-            break;
-        }
-        yield event;
+    let moderationReport;
+    const fetchStream = this.fetchStreamFn;
+    const adapter = this.adapter;
+    const queueName = this.queueName;
+    const priority = this.priority;
+    async function* rawEvents() {
+      for await (const sseEvent of fetchStream(httpReq, {
+        queueName,
+        priority,
+        ctx
+      })) {
+        for (const ev of adapter.parseStreamEvent(sseEvent)) yield ev;
+      }
+    }
+    const mod = options.moderation;
+    const emulate = !!mod && resolveModerationMode(this.provider, mod) === "emulate";
+    let eventStream = rawEvents();
+    if (mod && emulate && (mod.output ?? true)) {
+      const cfg = this.moderationConfig(mod);
+      const hooks = this.hooks;
+      const strategy = mod.stream?.strategy ?? MODERATION_DEFAULT_STRATEGY;
+      const interval = mod.stream?.interval ?? MODERATION_DEFAULT_INTERVAL;
+      eventStream = wrapModeratedStream(eventStream, strategy, interval, async (t) => {
+        const r = await runModeration(t, cfg);
+        emitModerationZeroCost(hooks, cfg.model);
+        return r;
+      });
+    }
+    if (mod && emulate && (mod.input ?? true)) {
+      const cfg = this.moderationConfig(mod);
+      const inputEntry = await runModeration(moderationInputText(normalized.messages), cfg);
+      emitModerationZeroCost(this.hooks, cfg.model);
+      moderationReport = this.mergeModeration(moderationReport, "input", inputEntry, "emulated");
+      yield { type: "moderation", phase: "input", result: inputEntry, source: "emulated" };
+    }
+    for await (const event of eventStream) {
+      switch (event.type) {
+        case "text":
+          text += event.text;
+          break;
+        case "thinking":
+          thinking += event.text;
+          break;
+        case "usage":
+          usage = event.usage;
+          break;
+        case "done":
+          finishReason = event.finishReason;
+          break;
+        case "moderation":
+          moderationReport = this.mergeModeration(
+            moderationReport,
+            event.phase,
+            event.result,
+            event.source
+          );
+          break;
       }
+      yield event;
     }
     const inputChars = JSON.stringify(normalized.messages).length;
     const response = {
@@ -22628,6 +22877,7 @@ var LLMClient = class {
       toolCalls: [],
       thinking: thinking || null,
       media: [],
+      ...moderationReport ? { moderation: moderationReport } : {},
       latencyMs: performance.now() - start,
       raw: null
     };
@@ -22936,6 +23186,9 @@ var AnthropicAdapter = class {
           if (t.type === "web_search") {
             return { type: "web_search_20250305", name: "web_search", max_uses: 5 };
           }
+          if (t.type === "code_interpreter") {
+            return { type: "code_execution_20260521", name: "code_execution" };
+          }
           return null;
         }
         const tool = {
@@ -23046,6 +23299,7 @@ var AnthropicAdapter = class {
     const content = [];
     let thinking = null;
     const toolCalls = [];
+    const files = [];
     for (const block of contentBlocks) {
       if (block.type === "text") {
         content.push({ type: "text", text: block.text });
@@ -23060,6 +23314,15 @@ var AnthropicAdapter = class {
         };
         content.push(tc);
         toolCalls.push(tc);
+      } else if (block.type === "code_execution_tool_result") {
+        const result = block.content;
+        if (result?.type === "code_execution_result" && Array.isArray(result.content)) {
+          for (const out of result.content) {
+            if (out.type === "code_execution_output" && typeof out.file_id === "string") {
+              files.push({ id: out.file_id, source: "code_execution" });
+            }
+          }
+        }
       }
     }
     const finishReason = extractFinishReason(toolCalls.length > 0, r.stop_reason, {
@@ -23074,6 +23337,7 @@ var AnthropicAdapter = class {
       text: content.filter((p) => p.type === "text").map((p) => p.text).join(""),
       toolCalls,
       media: [],
+      ...files.length ? { files } : {},
       thinking,
       latencyMs,
       raw
@@ -23379,6 +23643,17 @@ function resolveVoice(provider, voice) {
   return VOICE_ALIASES[provider]?.[voice] ?? voice;
 }
 
+// src/llm/providers/google/tiers.ts
+var REQUEST = /* @__PURE__ */ new Set(["flex", "standard", "priority"]);
+function googleRequestTier(t) {
+  if (!t) return void 0;
+  return REQUEST.has(t) ? t : void 0;
+}
+function googleBilledTier(raw) {
+  if (typeof raw !== "string" || !raw) return {};
+  return { serviceTier: raw, pricingTier: raw.toLowerCase() };
+}
+
 // src/llm/providers/google/constants.ts
 var GOOGLE_THINKING_LEVELS = {
   low: "LOW",
@@ -23431,6 +23706,8 @@ var GoogleAdapter = class {
       contents,
       generationConfig: config
     };
+    const tier = googleRequestTier(req.serviceTier);
+    if (tier) body.serviceTier = tier;
     if (req.system) {
       body.systemInstruction = { parts: [{ text: req.system }] };
     }
@@ -23689,7 +23966,9 @@ var GoogleAdapter = class {
       totalTokens: u.totalTokenCount ?? input + output,
       cachedTokens: u.cachedContentTokenCount ?? 0,
       cacheWriteTokens: 0,
-      reasoningTokens: u.thoughtsTokenCount ?? 0
+      reasoningTokens: u.thoughtsTokenCount ?? 0,
+      // Billed service tier (output-only `usageMetadata.serviceTier`).
+      ...googleBilledTier(u.serviceTier)
     };
   }
 };
@@ -24564,8 +24843,48 @@ var OpenAIBatchAdapter = class {
   }
 };
 
+// src/llm/moderation/native.ts
+function buildNativeModeration(mod) {
+  return { model: mod.model ?? MODERATION_DEFAULT_MODEL };
+}
+function parseNativeModeration(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const m = raw;
+  const input = parseEntry(m.input);
+  const output = parseEntry(m.output);
+  if (!input && !output) return void 0;
+  return {
+    source: "native",
+    ...input ? { input } : {},
+    ...output ? { output } : {}
+  };
+}
+function parseEntry(entry) {
+  if (!entry || typeof entry !== "object") return void 0;
+  const e = entry;
+  if (e.type === "error") {
+    return { error: String(e.message ?? e.code ?? "moderation error") };
+  }
+  if (e.type === "moderation_results" && Array.isArray(e.results)) {
+    const first = e.results[0];
+    return first ? toResult(first) : void 0;
+  }
+  if (e.type === "moderation_result" || e.categories) {
+    return toResult(e);
+  }
+  return void 0;
+}
+function toResult(r) {
+  return {
+    flagged: Boolean(r.flagged),
+    categories: r.categories ?? {},
+    categoryScores: r.category_scores ?? {},
+    categoryAppliedInputTypes: r.category_applied_input_types
+  };
+}
+
 // src/llm/providers/openai/tiers.ts
-var REQUEST = {
+var REQUEST2 = {
   auto: "auto",
   standard: "default",
   priority: "priority",
@@ -24575,7 +24894,7 @@ var REQUEST = {
 var KNOWN = /* @__PURE__ */ new Set(["auto", "default", "flex", "scale", "priority"]);
 function openaiRequestTier(t) {
   if (!t) return void 0;
-  const mapped = REQUEST[t] ?? t;
+  const mapped = REQUEST2[t] ?? t;
   return KNOWN.has(mapped) ? mapped : "auto";
 }
 function openaiBilledTier(raw) {
@@ -24634,6 +24953,9 @@ var OpenAIAdapter = class {
     if (req.stop) body.stop = req.stop;
     const tier = openaiRequestTier(req.serviceTier);
     if (tier) body.service_tier = tier;
+    if (req.moderation && req.moderation.mode !== "emulate") {
+      body.moderation = buildNativeModeration(req.moderation);
+    }
     const hasAudioInput = req.messages.some(
       (m) => Array.isArray(m.content) && m.content.some((p) => p.type === "audio")
     );
@@ -24792,6 +25114,7 @@ var OpenAIAdapter = class {
       { tool_calls: "tool_use", length: "length", content_filter: "content_filter" }
     );
     const reasoningContent = message.reasoning_content ?? null;
+    const moderation = parseNativeModeration(r.moderation);
     return {
       id: r.id,
       model: r.model,
@@ -24802,12 +25125,22 @@ var OpenAIAdapter = class {
       toolCalls,
       media,
       thinking: reasoningContent,
+      ...moderation ? { moderation } : {},
       latencyMs,
       raw
     };
   }
   parseStreamEvent(event) {
     const data = JSON.parse(event.data);
+    if (data.moderation) {
+      const report = parseNativeModeration(data.moderation);
+      const out = [];
+      if (report?.input)
+        out.push({ type: "moderation", phase: "input", result: report.input, source: "native" });
+      if (report?.output)
+        out.push({ type: "moderation", phase: "output", result: report.output, source: "native" });
+      if (out.length) return out;
+    }
     const choices = data.choices ?? [];
     const choice = choices[0];
     if (!choice) {
@@ -25408,6 +25741,9 @@ var OpenAIResponsesAdapter = class {
     if (req.topP !== void 0) body.top_p = req.topP;
     const tier = openaiRequestTier(req.serviceTier);
     if (tier) body.service_tier = tier;
+    if (req.moderation && req.moderation.mode !== "emulate") {
+      body.moderation = buildNativeModeration(req.moderation);
+    }
     if (req.tools?.length) {
       body.tools = req.tools.map((t) => {
         if (isFunctionTool(t)) {
@@ -25446,7 +25782,9 @@ var OpenAIResponsesAdapter = class {
     if (req.thinking && req.thinking.mode !== "off") {
       body.reasoning = {
         effort: req.thinking.effort ?? "medium",
-        summary: "auto"
+        summary: "auto",
+        // Cross-turn reasoning persistence (gpt-5/o-series, Responses only).
+        ...req.thinking.context ? { context: req.thinking.context } : {}
       };
     }
     return { body };
@@ -25590,6 +25928,7 @@ var OpenAIResponsesAdapter = class {
       text = r.output_text;
       if (text && content.length === 0) content.push({ type: "text", text });
     }
+    const moderation = parseNativeModeration(r.moderation);
     return {
       id: r.id,
       model: r.model ?? "",
@@ -25600,6 +25939,7 @@ var OpenAIResponsesAdapter = class {
       toolCalls,
       thinking,
       media,
+      ...moderation ? { moderation } : {},
       latencyMs,
       raw
     };
@@ -25654,6 +25994,11 @@ var OpenAIResponsesAdapter = class {
     }
     if (type === "response.completed") {
       const response = data.response ?? data;
+      const moderation = parseNativeModeration(response.moderation);
+      if (moderation?.input)
+        events.push({ type: "moderation", phase: "input", result: moderation.input, source: "native" });
+      if (moderation?.output)
+        events.push({ type: "moderation", phase: "output", result: moderation.output, source: "native" });
       const usage = response.usage;
       if (usage) events.push({ type: "usage", usage: this.parseUsage(usage) });
       events.push({
@@ -33533,43 +33878,6 @@ function handoff(name, description, agent, opts = {}) {
   });
 }
 
-// src/llm/providers/openai/moderations.ts
-var OPENAI_MODERATION_BASE_URL = "https://api.openai.com";
-var OPENAI_MODERATION_PATH = "/v1/moderations";
-var OPENAI_MODERATION_DEFAULT_MODEL = "omni-moderation-latest";
-var OpenAIModerationAdapter = class {
-  apiKey;
-  baseURL;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.baseURL = config.baseURL ?? OPENAI_MODERATION_BASE_URL;
-  }
-  async moderate(input, model, fetch2) {
-    const res = await fetch2({
-      url: `${this.baseURL}${OPENAI_MODERATION_PATH}`,
-      method: "POST",
-      headers: { authorization: `Bearer ${this.apiKey}`, "content-type": "application/json" },
-      body: { model, input },
-      provider: "openai",
-      model,
-      responseType: "json"
-    });
-    if (res.status >= 400) {
-      throw new Error(`OpenAI moderations failed (${res.status}): ${JSON.stringify(res.body)}`);
-    }
-    const data = res.body;
-    return (data.results ?? []).map(parseRawResult);
-  }
-};
-function parseRawResult(r) {
-  return {
-    flagged: r.flagged,
-    categories: r.categories,
-    categoryScores: r.category_scores,
-    categoryAppliedInputTypes: r.category_applied_input_types
-  };
-}
-
 // src/helpers/moderate.ts
 var MODERATION_COST_NOTE = "free: moderations endpoint not billed";
 var MODERATION_DEFAULT_PROVIDER = "openai";

package/dist/llm/client.d.ts

@@ -36,6 +36,7 @@ export declare class LLMClient {
     readonly mode: 'foreground' | 'background';
     readonly batchable: boolean;
     private readonly adapter;
+    private readonly apiKey;
     private readonly fetchFn;
     private readonly fetchStreamFn;
     private readonly priority;
@@ -58,6 +59,14 @@ export declare class LLMClient {
      *    const r2 = await llm.complete(messages); // sends id + only the new turn
      */
     assistantMessage(response: CompletionResponse): Message;
+    /** Resolve the OpenAI key the emulated moderation path needs. Reuses the
+     *  client's own key when the provider is OpenAI; otherwise requires an explicit
+     *  one. Throws when none is resolvable (report-only feature, but the call still
+     *  needs a key to reach the moderations endpoint). */
+    private resolveModerationKey;
+    private moderationConfig;
+    /** Fold a moderation stream event into the accumulating report. */
+    private mergeModeration;
     /** Submit a request. Returns the parsed CompletionResponse. */
     complete(input: string | ContentPart[] | Message[], options?: ExecuteOptions): Promise<CompletionResponse>;
     /** Run `complete` with a JSON Schema enforced via `structured`. Strips any