@combycode/llm-sdk 1.0.0-rc.0 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,43 @@ All notable changes to `@combycode/llm-sdk` are documented here. The format foll
 [Keep a Changelog](https://keepachangelog.com/) and the project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+## [1.1.0] - 2026-06-30
+
+### Added
+- Hosted MCP tool `tunnel_id` target (OpenAI Secure MCP Tunnel) — reach a private/local MCP
+  server with no public URL alongside the existing `server_url` / `connector_id` targets. The
+  `mcp` builtin already forwards `params`; added the exported `McpToolParams` type for editor
+  help and a regression test locking the forwarding. (Realtime MCP tooling tracked separately.)
+- `ThinkingConfig.context` (`'auto' | 'current_turn' | 'all_turns'`) — maps to OpenAI's
+  Responses `reasoning.context`, controlling which prior-turn reasoning items are rendered back
+  to the model across a stateful conversation. OpenAI Responses-only; ignored by other providers.
+- Inline moderation via the `moderation` request option on `complete()`/`stream()`
+  (parity with OpenAI's `moderation` request field, extended to all providers). Report-only:
+  results attach to `CompletionResponse.moderation` (`ModerationReport`) and never block the call.
+  Native on the OpenAI provider (one round-trip on both Responses and Chat Completions); emulated
+  via OpenAI's moderations endpoint on every other provider (`mode: 'native' | 'emulate'`).
+  Streaming supports three strategies (`buffer` default / `parallel` / `post`) trading latency for
+  how early the flag reaches the consumer, surfaced as a `moderation` stream event. Emulation
+  requires an OpenAI key (reused from the client when it is the OpenAI provider, else
+  `moderation.apiKey`); missing key throws.
+- Unified `CompletionResponse.files` (`FileOutput[]`) - files produced by hosted tools
+  (code execution, etc.), independent of `media`. The Anthropic adapter surfaces
+  code-execution file outputs there by file id; OpenAI/Google/xAI producers to follow.
+- Model catalog: new `ModelInfo.availability` field (`limited` / `preview`, vs default
+  generally-available) so gated / early-access models are distinguishable from the
+  `status` lifecycle. (Entries for specific limited/preview models are populated by the
+  catalog pipeline.)
+- Anthropic: the unified `code_interpreter` builtin now maps to Anthropic's hosted
+  `code_execution` tool (GA on Messages) - it was previously silently skipped. Hosted
+  code execution is now usable across Anthropic / OpenAI / Google through one interface.
+- Google service tier, both directions (parity with OpenAI/Anthropic): a requested
+  unified `serviceTier` (`flex`/`standard`/`priority`) maps to Google's top-level
+  request field, and the billed `usageMetadata.serviceTier` is read back into
+  `usage.serviceTier` / `usage.pricingTier` for tiered cost tracking.
+  (New `providers/google/tiers.ts`.)
+
 ## [1.0.0] - 2026-06-13
 
 First public release.
@@ -16,4 +53,5 @@ First public release.
 - Service tiers end to end (request → bill → cost).
 - Cross-environment: runs on Node, Bun, and the browser. ESM, zero runtime deps.
 
+[1.1.0]: https://github.com/combycode/llm-sdk-ts/releases/tag/v1.1.0
 [1.0.0]: https://github.com/combycode/llm-sdk-ts/releases/tag/v1.0.0

package/README.md

@@ -28,7 +28,7 @@ Requires Node ≥ 18 or Bun ≥ 1.1.
 import { complete } from '@combycode/llm-sdk';
 
 const r = await complete({
-  model: 'anthropic/claude-haiku-4-5', // provider/model, sent verbatim
+  model: 'anthropic/claude-haiku-4.5', // provider/model, sent verbatim
   apiKey: process.env.ANTHROPIC_API_KEY,
   prompt: 'Say hello in one word.',
 });

package/dist/index.browser.js

@@ -22177,6 +22177,7 @@ var ModelCatalog = class {
       family: info.family,
       version: info.version,
       status: info.status,
+      availability: info.availability,
       active: info.active,
       deprecation: info.deprecation
     });
@@ -22264,6 +22265,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,
@@ -22400,6 +22563,7 @@ var LLMClient = class {
   mode;
   batchable;
   adapter;
+  apiKey;
   fetchFn;
   fetchStreamFn;
   priority;
@@ -22423,6 +22587,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;
@@ -22476,6 +22641,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);
@@ -22496,6 +22689,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,
@@ -22551,6 +22745,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) {
@@ -22576,6 +22772,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,
@@ -22623,6 +22835,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,
@@ -22666,29 +22879,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 = {
@@ -22701,6 +22950,7 @@ var LLMClient = class {
       toolCalls: [],
       thinking: thinking || null,
       media: [],
+      ...moderationReport ? { moderation: moderationReport } : {},
       latencyMs: performance.now() - start,
       raw: null
     };
@@ -23009,6 +23259,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 = {
@@ -23119,6 +23372,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 });
@@ -23133,6 +23387,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, {
@@ -23147,6 +23410,7 @@ var AnthropicAdapter = class {
       text: content.filter((p) => p.type === "text").map((p) => p.text).join(""),
       toolCalls,
       media: [],
+      ...files.length ? { files } : {},
       thinking,
       latencyMs,
       raw
@@ -23452,6 +23716,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",
@@ -23504,6 +23779,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 }] };
     }
@@ -23762,7 +24039,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)
     };
   }
 };
@@ -24637,8 +24916,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",
@@ -24648,7 +24967,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) {
@@ -24707,6 +25026,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")
     );
@@ -24865,6 +25187,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,
@@ -24875,12 +25198,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) {
@@ -25481,6 +25814,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)) {
@@ -25519,7 +25855,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 };
@@ -25663,6 +26001,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 ?? "",
@@ -25673,6 +26012,7 @@ var OpenAIResponsesAdapter = class {
       toolCalls,
       thinking,
       media,
+      ...moderation ? { moderation } : {},
       latencyMs,
       raw
     };
@@ -25727,6 +26067,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({
@@ -33606,43 +33951,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";