@combycode/llm-sdk 1.0.0 → 1.2.0

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 = {
@@ -23052,7 +23305,10 @@ var AnthropicAdapter = class {
     });
     const headers = {};
     if (hasFileRef) headers["anthropic-beta"] = "files-api-2025-04-14";
-    return { body, headers };
+    const usesCodeExec = req.tools?.some(
+      (t) => !isFunctionTool(t) && t.type === "code_interpreter"
+    );
+    return { body, headers, ...usesCodeExec ? { path: "/v1/messages?beta=true" } : {} };
   }
   enableStreaming(providerReq, _req) {
     providerReq.body.stream = true;
@@ -23119,6 +23375,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 +23390,15 @@ var AnthropicAdapter = class {
         };
         content.push(tc);
         toolCalls.push(tc);
+      } else if (block.type === "bash_code_execution_tool_result" || block.type === "code_execution_tool_result") {
+        const result = block.content;
+        if (result && (result.type === "bash_code_execution_result" || result.type === "code_execution_result") && Array.isArray(result.content)) {
+          for (const out of result.content) {
+            if ((out.type === "bash_code_execution_output" || 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 +23413,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 +23719,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 +23782,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 }] };
     }
@@ -23622,7 +23902,9 @@ var GoogleAdapter = class {
     const content = [];
     const toolCalls = [];
     const media = [];
+    const files = [];
     let thinking = null;
+    const hasCodeExec = parts.some((p) => p.executableCode || p.codeExecutionResult);
     for (const part of parts) {
       if (part.text !== void 0 && !part.thought) {
         content.push({ type: "text", text: part.text });
@@ -23633,7 +23915,9 @@ var GoogleAdapter = class {
       if (part.inlineData) {
         const inline = part.inlineData;
         const mime = inline.mimeType;
-        if (mime.startsWith("image/")) {
+        if (hasCodeExec) {
+          files.push({ data: inline.data, mimeType: mime, source: "code_execution" });
+        } else if (mime.startsWith("image/")) {
           const p = {
             type: "image_output",
             mediaId: "",
@@ -23694,6 +23978,7 @@ var GoogleAdapter = class {
       toolCalls,
       thinking,
       media,
+      ...files.length ? { files } : {},
       latencyMs,
       raw
     };
@@ -23762,7 +24047,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 +24924,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 +24975,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 +25034,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 +25195,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 +25206,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 +25822,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 +25863,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 };
@@ -25611,6 +25957,7 @@ var OpenAIResponsesAdapter = class {
     const content = [];
     const toolCalls = [];
     const media = [];
+    const files = [];
     let thinking = null;
     let text = "";
     for (const item of output) {
@@ -25622,6 +25969,22 @@ var OpenAIResponsesAdapter = class {
             const t = c.text;
             text += t;
             content.push({ type: "text", text: t });
+            for (const a of c.annotations ?? []) {
+              if (a.type === "container_file_citation" && typeof a.file_id === "string") {
+                files.push({
+                  id: a.file_id,
+                  ...typeof a.filename === "string" ? { name: a.filename } : {},
+                  source: "code_execution"
+                });
+              }
+            }
+          }
+        }
+      }
+      if (type === "code_interpreter_call") {
+        for (const out of item.outputs ?? []) {
+          if (out.type === "image" && typeof out.url === "string") {
+            files.push({ url: out.url, source: "code_execution" });
           }
         }
       }
@@ -25663,6 +26026,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 +26037,8 @@ var OpenAIResponsesAdapter = class {
       toolCalls,
       thinking,
       media,
+      ...files.length ? { files } : {},
+      ...moderation ? { moderation } : {},
       latencyMs,
       raw
     };
@@ -25727,6 +26093,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({
@@ -27393,6 +27764,7 @@ var AgentLoop = class _AgentLoop {
   _toolTimeout;
   _maxSteps;
   _guardrails;
+  _toolInputGuardrails;
   _policy;
   _approve;
   _checkpoint;
@@ -27420,6 +27792,7 @@ var AgentLoop = class _AgentLoop {
     this._toolTimeout = config.toolTimeout ?? DEFAULT_TOOL_TIMEOUT_MS;
     this._maxSteps = config.maxSteps !== void 0 && config.maxSteps > 0 ? config.maxSteps : DEFAULT_MAX_STEPS;
     this._guardrails = config.guardrails ?? [];
+    this._toolInputGuardrails = config.toolInputGuardrails ?? [];
     this._policy = config.policy ?? null;
     this._approve = config.approve ?? null;
     this._checkpoint = config.checkpoint ?? null;
@@ -27638,6 +28011,10 @@ var AgentLoop = class _AgentLoop {
       toolCalls: lastResponse?.toolCalls ?? [],
       thinking: lastResponse?.thinking ?? null,
       media: lastResponse?.media ?? [],
+      // Propagate hosted-tool file outputs + inline-moderation result from the final
+      // LLM response (e.g. code-execution files produced during the run).
+      ...lastResponse?.files ? { files: lastResponse.files } : {},
+      ...lastResponse?.moderation ? { moderation: lastResponse.moderation } : {},
       latencyMs: performance.now() - startPerf,
       raw: lastResponse?.raw ?? null
     };
@@ -27832,6 +28209,8 @@ var AgentLoop = class _AgentLoop {
       toolCalls: lastResponse?.toolCalls ?? [],
       thinking: lastResponse?.thinking ?? null,
       media: [],
+      ...lastResponse?.files ? { files: lastResponse.files } : {},
+      ...lastResponse?.moderation ? { moderation: lastResponse.moderation } : {},
       latencyMs: performance.now() - startPerf,
       raw: null
     };
@@ -27918,6 +28297,18 @@ var AgentLoop = class _AgentLoop {
       runTrace
     );
     if (!lookup.found) return lookup.errorResult;
+    for (const g of this._toolInputGuardrails) {
+      const decision = await g.check({
+        toolName: tc.name,
+        arguments: tc.arguments,
+        callId: tc.id,
+        step,
+        trace: { sessionId: runTrace.sessionId, requestId: runTrace.requestId, callId: tc.id }
+      });
+      if (!decision.pass) {
+        return this.buildDeniedResult(tc, decision.reason, reports);
+      }
+    }
     if (this._policy !== null) {
       const target = {
         kind: "tool",
@@ -27934,7 +28325,7 @@ var AgentLoop = class _AgentLoop {
     try {
       const baseCtx = { step, callId: tc.id, metrics, trace: { sessionId: runTrace.sessionId, requestId: runTrace.requestId, callId: tc.id } };
       const result = await executeWithTimeout(lookup.tool, tc, baseCtx, this._toolTimeout);
-      return await this.buildSuccessResult(tc, result, runId, step, metrics, reports, toolStart, runTrace);
+      return await this.buildSuccessResult(tc, result, runId, step, metrics, reports, toolStart, runTrace, lookup.tool, baseCtx);
     } catch (e) {
       return handleToolError(e, tc, this.hooks, runId, this.id, step, metrics, reports, toolStart, runTrace);
     }
@@ -28025,7 +28416,7 @@ var AgentLoop = class _AgentLoop {
       try {
         const baseCtx = { step, callId: tc.id, metrics, trace: { sessionId: runTrace.sessionId, requestId: runTrace.requestId, callId: tc.id } };
         const result = await executeWithTimeout(tool, tc, baseCtx, this._toolTimeout);
-        return await this.buildSuccessResult(tc, result, runId, step, metrics, reports, toolStart, runTrace);
+        return await this.buildSuccessResult(tc, result, runId, step, metrics, reports, toolStart, runTrace, tool, baseCtx);
       } catch (e) {
         return handleToolError(e, tc, this.hooks, runId, this.id, step, metrics, reports, toolStart, runTrace);
       }
@@ -28037,9 +28428,16 @@ var AgentLoop = class _AgentLoop {
     return this.buildDeniedResult(tc, denyMsg, reports);
   }
   /** Emit onToolCallComplete, push report, and return success content part. */
-  async buildSuccessResult(tc, result, runId, step, metrics, reports, toolStart, runTrace) {
+  async buildSuccessResult(tc, result, runId, step, metrics, reports, toolStart, runTrace, tool, context) {
     const latencyMs = performance.now() - toolStart;
     const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+    let customData;
+    if (tool?.customDataExtractor && context) {
+      try {
+        customData = await tool.customDataExtractor(result, tc.arguments, context);
+      } catch {
+      }
+    }
     await this.hooks.emit("onToolCallComplete", {
       runId,
       agentId: this.id,
@@ -28061,7 +28459,8 @@ var AgentLoop = class _AgentLoop {
       latencyMs,
       skipped: false,
       error: null,
-      metrics: Object.fromEntries(metrics)
+      metrics: Object.fromEntries(metrics),
+      ...customData !== void 0 ? { customData } : {}
     });
     return { type: "tool_result", id: tc.id, content: resultStr };
   }
@@ -33606,43 +34005,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";