@omnicross/core 0.2.0 → 0.3.0

package/dist/{chunk-DEIUR2TH.js → chunk-LQYS2N47.js}

@@ -1765,7 +1765,10 @@ async function readJsonBody(request2, options) {
 
 // src/image-generation/openai-images/types.ts
 var DEFAULT_IMAGE_API_LIMITS = Object.freeze({
-  maxJsonBytes: 1024 * 1024,
+  // Codex's built-in image tool sends edits as JSON data URLs rather than
+  // multipart files. Leave room for the Base64 expansion of the bounded
+  // aggregate input budget plus the small JSON/options envelope.
+  maxJsonBytes: 96 * 1024 * 1024,
   maxMultipartBytes: 64 * 1024 * 1024,
   maxFileBytes: 50 * 1024 * 1024,
   maxTotalInputBytes: 64 * 1024 * 1024,
@@ -2326,7 +2329,7 @@ async function readMultipartEdit(request2, scope, limits, signal) {
 function invalid4(param = "image") {
   throw new ImageGenerationError("invalid_image_request", { param });
 }
-function closedInput(value, maxRemoteUrlBytes) {
+function closedInput(value, limits) {
   if (!value || typeof value !== "object" || Array.isArray(value)) invalid4();
   const record2 = value;
   const keys = Object.keys(record2);
@@ -2334,8 +2337,9 @@ function closedInput(value, maxRemoteUrlBytes) {
   const key = keys[0];
   if (key !== "file_id" && key !== "image_url") invalid4();
   const item = record2[key];
-  const maxBytes = key === "file_id" ? 256 : maxRemoteUrlBytes;
-  if (typeof item !== "string" || !item || Buffer.byteLength(item, "utf8") > maxBytes) invalid4();
+  if (typeof item !== "string" || !item) invalid4();
+  const maxBytes = key === "file_id" ? 256 : item.toLowerCase().startsWith("data:") ? Math.ceil(limits.maxFileBytes / 3) * 4 + 64 : limits.maxRemoteUrlBytes;
+  if (Buffer.byteLength(item, "utf8") > maxBytes) invalid4();
   return { [key]: item };
 }
 function decodedBase64Length(value) {
@@ -2407,7 +2411,7 @@ async function resolveReference(referenceId, runtime, scope) {
   return asset;
 }
 async function resolveImageInput(value, runtime, scope, signal) {
-  const input = closedInput(value, runtime.limits.maxRemoteUrlBytes);
+  const input = closedInput(value, runtime.limits);
   if ("file_id" in input) return resolveReference(input.file_id, runtime, scope);
   if (input.image_url.toLowerCase().startsWith("data:")) {
     return resolveDataUrl(input.image_url, runtime, scope, signal);
@@ -2432,10 +2436,10 @@ async function resolveImageInput(value, runtime, scope, signal) {
     materializer
   });
 }
-function parseImageInputList(value, maxRemoteUrlBytes) {
+function parseImageInputList(value, limits) {
   const list = Array.isArray(value) ? value : [value];
   if (list.length < 1 || list.length > 16) invalid4();
-  for (const item of list) closedInput(item, maxRemoteUrlBytes);
+  for (const item of list) closedInput(item, limits);
   return list;
 }
 
@@ -2481,7 +2485,7 @@ function createImageEditHandler(deps) {
         });
         const inputs = parseImageInputList(
           record2.images ?? record2.image,
-          runtime.limits.maxRemoteUrlBytes
+          runtime.limits
         );
         const resolveObservedInput = async (input) => {
           const reference = isReferenceInput(input);

package/dist/chunk-MZEGQSKQ.js

@@ -0,0 +1,118 @@
+// src/search/frontends.ts
+var SEARCH_FRONTEND_NAMES = Object.freeze([
+  "codex",
+  "responses",
+  "anthropic"
+]);
+var SEARCH_FRONTEND_MODES = Object.freeze([
+  "native",
+  "managed",
+  "off"
+]);
+var DEFAULT_SEARCH_FRONTEND_MODES = Object.freeze({
+  codex: "off",
+  responses: "native",
+  anthropic: "native"
+});
+var SEARCH_UNSUPPORTED_CAPABILITY_CODE = "unsupported_capability";
+function searchErrorHttpStatus(code) {
+  switch (code) {
+    case "rate_limited":
+      return 429;
+    case "timeout":
+      return 504;
+    case "cancelled":
+      return 499;
+    case "config_missing":
+      return 503;
+    case "auth_failed":
+    case "upstream_unavailable":
+    case "parse_failed":
+    case "policy_denied":
+      return 502;
+    default:
+      return 502;
+  }
+}
+function isSearchFrontendMode(value) {
+  return typeof value === "string" && SEARCH_FRONTEND_MODES.includes(value);
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function normalizeSearchFrontendModes(value) {
+  const raw = record(value) ?? {};
+  const modes = {
+    ...DEFAULT_SEARCH_FRONTEND_MODES
+  };
+  for (const name of SEARCH_FRONTEND_NAMES) {
+    const candidate = raw[name];
+    if (isSearchFrontendMode(candidate)) modes[name] = candidate;
+  }
+  return Object.freeze(modes);
+}
+function validateSearchFrontendModes(value, path = "$.search.modes") {
+  if (value === void 0) return [];
+  const raw = record(value);
+  if (!raw) return [`${path}: expected an object`];
+  const errors = [];
+  for (const [key, candidate] of Object.entries(raw)) {
+    if (!SEARCH_FRONTEND_NAMES.includes(key)) {
+      errors.push(`${path}.${key}: unknown frontend (expected ${SEARCH_FRONTEND_NAMES.join(", ")})`);
+      continue;
+    }
+    if (isSearchFrontendMode(candidate)) continue;
+    errors.push(
+      `${path}.${key}: not a mode (got ${typeof candidate}; expected ${SEARCH_FRONTEND_MODES.join(", ")})`
+    );
+  }
+  return errors;
+}
+
+// src/search/webSearchBackendCompat.ts
+import {
+  searchErrorToLegacyWebSearchResponse,
+  toLegacyWebSearchResponse
+} from "@omnicross/contracts/search-compat";
+import { toSearchErrorShape } from "@omnicross/contracts/search-types";
+function searchRuntimeAsWebSearchBackend(runtime, options = {}) {
+  return {
+    async search(query, providerId, searchOptions) {
+      try {
+        const response = await runtime.search({
+          query,
+          provider: providerId,
+          // `WebSearchOptions` is a strict subset of `SearchOptions` with
+          // identical field names — asserted in the contracts tests.
+          ...searchOptions === void 0 ? {} : { options: searchOptions }
+        });
+        return toLegacyWebSearchResponse(response);
+      } catch (error) {
+        return searchErrorToLegacyWebSearchResponse(query, toSearchErrorShape(error));
+      }
+    },
+    isProviderEnabled(id) {
+      return runtime.listProviders().some((descriptor) => descriptor.id === id);
+    },
+    async readUrl(url, readOptions) {
+      if (options.readUrl !== void 0) return options.readUrl(url, readOptions);
+      return {
+        success: false,
+        url,
+        error: "URL reading is not available through the search runtime adapter"
+      };
+    }
+  };
+}
+
+export {
+  SEARCH_FRONTEND_NAMES,
+  SEARCH_FRONTEND_MODES,
+  DEFAULT_SEARCH_FRONTEND_MODES,
+  SEARCH_UNSUPPORTED_CAPABILITY_CODE,
+  searchErrorHttpStatus,
+  isSearchFrontendMode,
+  normalizeSearchFrontendModes,
+  validateSearchFrontendModes,
+  searchRuntimeAsWebSearchBackend
+};

package/dist/chunk-PTU7SXM3.cjs

@@ -0,0 +1,386 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkBTBEJRGLcjs = require('./chunk-BTBEJRGL.cjs');
+
+// src/search/orchestrator.ts
+var _searchtypes = require('@omnicross/contracts/search-types');
+var _crypto = require('crypto');
+
+// src/search/normalize.ts
+var DEFAULT_NORMALIZED_MAX_RESULTS = 5;
+var SERP_REDIRECT_RULES = [
+  { domain: "google.com", paths: ["/search", "/goto"] },
+  { domain: "bing.com", paths: ["/search"] },
+  { domain: "duckduckgo.com", paths: ["/html/", "/l/"] },
+  { domain: "baidu.com", paths: ["/s"] }
+];
+function isDirectResultUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch (e) {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  const host = url.hostname.toLowerCase();
+  for (const rule of SERP_REDIRECT_RULES) {
+    if (host !== rule.domain && !host.endsWith(`.${rule.domain}`)) continue;
+    if (rule.paths.includes(url.pathname)) return false;
+  }
+  return true;
+}
+function normalizedResultLimit(maxResults) {
+  const requested = maxResults === void 0 || !Number.isFinite(maxResults) ? DEFAULT_NORMALIZED_MAX_RESULTS : Math.floor(maxResults);
+  return Math.max(1, requested);
+}
+function normalizeSearchResults(results, maxResults) {
+  const limit = normalizedResultLimit(maxResults);
+  const seenUrls = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const result of results) {
+    if (result === null || typeof result !== "object") continue;
+    const title = typeof result.title === "string" ? result.title.trim() : "";
+    const url = typeof result.url === "string" ? result.url.trim() : "";
+    if (title.length === 0 || !isDirectResultUrl(url)) continue;
+    if (seenUrls.has(url)) continue;
+    seenUrls.add(url);
+    normalized.push({
+      title,
+      url,
+      content: typeof result.content === "string" ? result.content.trim() : ""
+    });
+    if (normalized.length >= limit) break;
+  }
+  return normalized;
+}
+
+// src/search/orchestrator.ts
+var QUERY_HASH_LENGTH = 12;
+function hashSearchQuery(query) {
+  return _crypto.createHash.call(void 0, "sha256").update(query).digest("hex").slice(0, QUERY_HASH_LENGTH);
+}
+var SearchOrchestrator = class {
+  
+  
+  
+  constructor(registry, options = {}) {
+    this.registry = registry;
+    this.defaultPolicy = _nullishCoalesce(options.policy, () => ( {}));
+    this.onEvent = options.onEvent;
+  }
+  /**
+   * Run one search.
+   *
+   * @param request - the query, an optional pinned provider, and per-request
+   *   options. `options` is passed to the provider untouched: providers own
+   *   their own timeouts and the orchestrator adds no second timeout layer.
+   * @param policyOverride - per-request policy, merged field-by-field over the
+   *   orchestrator's default.
+   * @throws {SearchProviderError} when no provider produced a response.
+   */
+  async search(request, policyOverride) {
+    const policy = { ...this.defaultPolicy, ...policyOverride };
+    const requestId = _crypto.randomUUID.call(void 0, );
+    const queryHash = hashSearchQuery(request.query);
+    const startedAt = Date.now();
+    const attempts = [];
+    const emitComplete = (providerId, resultCount) => {
+      this.emit({
+        type: "search_complete",
+        requestId,
+        queryHash,
+        ...providerId === void 0 ? {} : { providerId },
+        resultCount,
+        fallbackCount: fallbackCountOf(attempts),
+        durationMs: Date.now() - startedAt
+      });
+    };
+    let plan;
+    try {
+      plan = this.planCandidates(request, policy);
+    } catch (error) {
+      emitComplete(void 0, 0);
+      throw error;
+    }
+    if (plan.skippedPreferred !== void 0) {
+      this.emit({
+        type: "search_attempt",
+        requestId,
+        queryHash,
+        providerId: plan.skippedPreferred.providerId,
+        outcome: "failed",
+        errorCode: plan.skippedPreferred.errorCode,
+        durationMs: 0
+      });
+    }
+    let lastError;
+    for (const candidate of plan.candidates) {
+      const attemptStartedAt = Date.now();
+      try {
+        const produced = await candidate.provider.search(request.query, request.options);
+        const durationMs = Date.now() - attemptStartedAt;
+        const results = normalizeSearchResults(produced, _optionalChain([request, 'access', _ => _.options, 'optionalAccess', _2 => _2.maxResults]));
+        attempts.push({
+          providerId: candidate.id,
+          outcome: "success",
+          resultCount: results.length,
+          durationMs
+        });
+        this.emit({
+          type: "search_attempt",
+          requestId,
+          queryHash,
+          providerId: candidate.id,
+          outcome: "success",
+          resultCount: results.length,
+          durationMs
+        });
+        emitComplete(candidate.id, results.length);
+        return {
+          query: request.query,
+          providerId: candidate.id,
+          results,
+          attempts,
+          fallbackCount: fallbackCountOf(attempts)
+        };
+      } catch (error) {
+        const durationMs = Date.now() - attemptStartedAt;
+        const shape = _searchtypes.toSearchErrorShape.call(void 0, error);
+        const isCancelled = shape.code === "cancelled" || _optionalChain([request, 'access', _3 => _3.options, 'optionalAccess', _4 => _4.signal, 'optionalAccess', _5 => _5.aborted]) === true;
+        const errorCode = isCancelled ? "cancelled" : shape.code;
+        attempts.push({
+          providerId: candidate.id,
+          outcome: "failed",
+          errorCode,
+          durationMs
+        });
+        this.emit({
+          type: "search_attempt",
+          requestId,
+          queryHash,
+          providerId: candidate.id,
+          outcome: "failed",
+          errorCode,
+          durationMs
+        });
+        if (isCancelled) {
+          emitComplete(void 0, 0);
+          throw shape.code === "cancelled" ? error : new (0, _searchtypes.SearchProviderError)("cancelled", "search was cancelled by the caller", {
+            providerId: candidate.id,
+            retryable: false,
+            cause: error
+          });
+        }
+        lastError = asSearchProviderError(error, shape.code, shape.message, candidate.id);
+      }
+    }
+    emitComplete(void 0, 0);
+    throw exhaustionError(attempts, lastError);
+  }
+  /** Resolve the candidate list for one request. */
+  planCandidates(request, policy) {
+    if (request.provider !== void 0) {
+      const pinned = this.registry.get(request.provider);
+      if (pinned === void 0) {
+        throw new (0, _searchtypes.SearchProviderError)(
+          "upstream_unavailable",
+          `search provider '${request.provider}' is not registered in this runtime`,
+          { providerId: request.provider, retryable: false }
+        );
+      }
+      if (!isAllowed(pinned.id, policy)) {
+        throw new (0, _searchtypes.SearchProviderError)(
+          "policy_denied",
+          `search provider '${request.provider}' is not allowed by the active search policy`,
+          { providerId: request.provider, retryable: false }
+        );
+      }
+      return { candidates: [pinned] };
+    }
+    const allowed = this.registry.list().filter((entry) => isAllowed(entry.id, policy));
+    let ordered = allowed;
+    let skippedPreferred;
+    if (policy.preferred !== void 0) {
+      const preferred = allowed.find((entry) => entry.id === policy.preferred);
+      if (preferred === void 0) {
+        skippedPreferred = {
+          providerId: policy.preferred,
+          errorCode: this.registry.has(policy.preferred) ? "policy_denied" : "upstream_unavailable"
+        };
+      } else {
+        ordered = [preferred, ...allowed.filter((entry) => entry.id !== preferred.id)];
+      }
+    }
+    if (policy.fallbackEnabled === false) ordered = ordered.slice(0, 1);
+    if (policy.maxAttempts !== void 0) {
+      ordered = ordered.slice(0, Math.max(0, Math.floor(policy.maxAttempts)));
+    }
+    return { candidates: ordered, ...skippedPreferred === void 0 ? {} : { skippedPreferred } };
+  }
+  /** Deliver one event. A listener that throws must never fail a search. */
+  emit(event) {
+    if (this.onEvent === void 0) return;
+    try {
+      this.onEvent(event);
+    } catch (e2) {
+    }
+  }
+};
+function fallbackCountOf(attempts) {
+  return Math.max(0, attempts.length - 1);
+}
+function isAllowed(id, policy) {
+  return policy.allowed === void 0 || policy.allowed.includes(id);
+}
+function asSearchProviderError(error, code, message, providerId) {
+  if (error instanceof _searchtypes.SearchProviderError) return error;
+  return new (0, _searchtypes.SearchProviderError)(code, message, { providerId, cause: error });
+}
+function exhaustionError(attempts, lastError) {
+  if (attempts.length === 1 && lastError !== void 0) return lastError;
+  if (attempts.length === 0) {
+    return new (0, _searchtypes.SearchProviderError)(
+      "upstream_unavailable",
+      "no eligible search provider was available (0 attempts)",
+      { retryable: false }
+    );
+  }
+  const trail = attempts.map((attempt) => `${attempt.providerId}:${_nullishCoalesce(attempt.errorCode, () => ( "unknown"))}`).join(",");
+  return new (0, _searchtypes.SearchProviderError)(
+    _nullishCoalesce(_optionalChain([lastError, 'optionalAccess', _6 => _6.code]), () => ( "upstream_unavailable")),
+    `search failed after ${attempts.length} attempt(s)`,
+    { retryable: _optionalChain([lastError, 'optionalAccess', _7 => _7.retryable]), details: { attempts: trail }, cause: lastError }
+  );
+}
+
+// src/search/registry.ts
+var SearchRegistryError = class _SearchRegistryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SearchRegistryError";
+    Object.setPrototypeOf(this, _SearchRegistryError.prototype);
+  }
+};
+var SearchProviderRegistry = (_class = class {
+  __init() {this.entries = /* @__PURE__ */ new Map()}
+  
+  __init2() {this.nextSequence = 0}
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.allowBuiltinOverride = options.allowBuiltinOverride === true;
+  }
+  /**
+   * Register one provider.
+   *
+   * @param contribution - the provider with its origin, transport, and
+   *   capabilities declared.
+   * @param context - who is registering, for a Phase-2 host. Retained as-is;
+   *   no rule reads it today, and the parameter exists so adding one later is
+   *   not a signature change for every caller.
+   * @throws {SearchRegistryError} on a blank id, a duplicate id, or a host
+   *   contribution colliding with a builtin without `allowBuiltinOverride`.
+   */
+  register(contribution, context) {
+    const id = contribution.id;
+    if (typeof id !== "string" || id.trim().length === 0) {
+      throw new SearchRegistryError("a search provider contribution needs a non-blank id");
+    }
+    const existing = this.entries.get(id);
+    let sequence = this.nextSequence;
+    if (existing !== void 0) {
+      const isPermittedOverride = this.allowBuiltinOverride && contribution.source === "host" && existing.contribution.source === "builtin";
+      if (!isPermittedOverride) {
+        throw new SearchRegistryError(
+          existing.contribution.source === "builtin" && contribution.source === "host" ? `search provider '${id}' is a builtin; overriding it requires allowBuiltinOverride` : `search provider '${id}' is already registered`
+        );
+      }
+      sequence = existing.sequence;
+    } else {
+      this.nextSequence += 1;
+    }
+    this.entries.set(id, { contribution, context, sequence });
+  }
+  /** Whether an id is currently registered. */
+  has(id) {
+    return this.entries.has(id);
+  }
+  /** The contribution registered under `id`, if any. */
+  get(id) {
+    return _optionalChain([this, 'access', _8 => _8.entries, 'access', _9 => _9.get, 'call', _10 => _10(id), 'optionalAccess', _11 => _11.contribution]);
+  }
+  /**
+   * Remove a provider.
+   *
+   * The Phase-2 host-disconnect hook: when a host goes away its contributions
+   * go with it, and the id becomes free to register again.
+   *
+   * @returns whether something was removed.
+   */
+  unregister(id) {
+    return this.entries.delete(id);
+  }
+  /**
+   * Every registered contribution, in candidate order.
+   *
+   * `priorityHint` ascending; contributions without a hint come AFTER every
+   * hinted one (an absent hint is "no opinion", not "highest priority"); ties
+   * keep registration order. The builtin HTTP contributions carry no hints, so
+   * today this is exactly registration order.
+   */
+  list() {
+    return [...this.entries.values()].sort((a, b) => {
+      const aHint = a.contribution.priorityHint;
+      const bHint = b.contribution.priorityHint;
+      if (aHint !== bHint) {
+        if (aHint === void 0) return 1;
+        if (bHint === void 0) return -1;
+        return aHint - bHint;
+      }
+      return a.sequence - b.sequence;
+    }).map((entry) => entry.contribution);
+  }
+}, _class);
+
+// src/search/runtime.ts
+function createSearchRuntime(options = {}) {
+  const registry = new SearchProviderRegistry({
+    allowBuiltinOverride: options.allowBuiltinOverride === true
+  });
+  for (const contribution of _nullishCoalesce(options.contributions, () => ( _chunkBTBEJRGLcjs.builtinHttpSearchContributions.call(void 0, )))) {
+    registry.register(contribution);
+  }
+  const orchestrator = new SearchOrchestrator(registry, {
+    ...options.policy === void 0 ? {} : { policy: options.policy },
+    ...options.onEvent === void 0 ? {} : { onEvent: options.onEvent }
+  });
+  return {
+    search(request) {
+      return orchestrator.search(request);
+    },
+    registerContribution(contribution, context) {
+      registry.register(contribution, context);
+    },
+    unregisterContribution(id) {
+      return registry.unregister(id);
+    },
+    listProviders() {
+      return registry.list().map((contribution) => ({
+        id: contribution.id,
+        source: contribution.source,
+        kind: contribution.kind,
+        capabilities: { ...contribution.capabilities }
+      }));
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_NORMALIZED_MAX_RESULTS = DEFAULT_NORMALIZED_MAX_RESULTS; exports.isDirectResultUrl = isDirectResultUrl; exports.normalizedResultLimit = normalizedResultLimit; exports.normalizeSearchResults = normalizeSearchResults; exports.hashSearchQuery = hashSearchQuery; exports.SearchOrchestrator = SearchOrchestrator; exports.SearchRegistryError = SearchRegistryError; exports.SearchProviderRegistry = SearchProviderRegistry; exports.createSearchRuntime = createSearchRuntime;

package/dist/{chunk-CTKM773J.cjs → chunk-UPQIWJIE.cjs}

@@ -1765,7 +1765,10 @@ async function readJsonBody(request2, options) {
 
 // src/image-generation/openai-images/types.ts
 var DEFAULT_IMAGE_API_LIMITS = Object.freeze({
-  maxJsonBytes: 1024 * 1024,
+  // Codex's built-in image tool sends edits as JSON data URLs rather than
+  // multipart files. Leave room for the Base64 expansion of the bounded
+  // aggregate input budget plus the small JSON/options envelope.
+  maxJsonBytes: 96 * 1024 * 1024,
   maxMultipartBytes: 64 * 1024 * 1024,
   maxFileBytes: 50 * 1024 * 1024,
   maxTotalInputBytes: 64 * 1024 * 1024,
@@ -2326,7 +2329,7 @@ async function readMultipartEdit(request2, scope, limits, signal) {
 function invalid4(param = "image") {
   throw new ImageGenerationError("invalid_image_request", { param });
 }
-function closedInput(value, maxRemoteUrlBytes) {
+function closedInput(value, limits) {
   if (!value || typeof value !== "object" || Array.isArray(value)) invalid4();
   const record2 = value;
   const keys = Object.keys(record2);
@@ -2334,8 +2337,9 @@ function closedInput(value, maxRemoteUrlBytes) {
   const key = keys[0];
   if (key !== "file_id" && key !== "image_url") invalid4();
   const item = record2[key];
-  const maxBytes = key === "file_id" ? 256 : maxRemoteUrlBytes;
-  if (typeof item !== "string" || !item || Buffer.byteLength(item, "utf8") > maxBytes) invalid4();
+  if (typeof item !== "string" || !item) invalid4();
+  const maxBytes = key === "file_id" ? 256 : item.toLowerCase().startsWith("data:") ? Math.ceil(limits.maxFileBytes / 3) * 4 + 64 : limits.maxRemoteUrlBytes;
+  if (Buffer.byteLength(item, "utf8") > maxBytes) invalid4();
   return { [key]: item };
 }
 function decodedBase64Length(value) {
@@ -2407,7 +2411,7 @@ async function resolveReference(referenceId, runtime, scope) {
   return asset;
 }
 async function resolveImageInput(value, runtime, scope, signal) {
-  const input = closedInput(value, runtime.limits.maxRemoteUrlBytes);
+  const input = closedInput(value, runtime.limits);
   if ("file_id" in input) return resolveReference(input.file_id, runtime, scope);
   if (input.image_url.toLowerCase().startsWith("data:")) {
     return resolveDataUrl(input.image_url, runtime, scope, signal);
@@ -2432,10 +2436,10 @@ async function resolveImageInput(value, runtime, scope, signal) {
     materializer
   });
 }
-function parseImageInputList(value, maxRemoteUrlBytes) {
+function parseImageInputList(value, limits) {
   const list = Array.isArray(value) ? value : [value];
   if (list.length < 1 || list.length > 16) invalid4();
-  for (const item of list) closedInput(item, maxRemoteUrlBytes);
+  for (const item of list) closedInput(item, limits);
   return list;
 }
 
@@ -2481,7 +2485,7 @@ function createImageEditHandler(deps) {
         });
         const inputs = parseImageInputList(
           _nullishCoalesce(record2.images, () => ( record2.image)),
-          runtime.limits.maxRemoteUrlBytes
+          runtime.limits
         );
         const resolveObservedInput = async (input) => {
           const reference = isReferenceInput(input);

package/dist/{chunk-CFSGYFOZ.js → chunk-VL5TUDTM.js}

@@ -32,6 +32,12 @@ function bumpUpstreamProxyGeneration() {
     }
   }
 }
+function isClientDisconnectAbort(signal) {
+  if (!signal?.aborted) return false;
+  const reason = signal.reason;
+  if (!reason || typeof reason !== "object") return false;
+  return reason.code === "client_disconnect";
+}
 function normalizeProxy(cfg) {
   if ("url" in cfg) {
     let u;
@@ -144,7 +150,7 @@ function fetchUpstream(url, init, ctx) {
       return response;
     },
     (error) => {
-      recordActivity(0);
+      if (!isClientDisconnectAbort(init.signal)) recordActivity(0);
       throw error;
     }
   );