@organizaone/o1-code 0.11.3 → 0.12.0

package/chunks/{chunk-HUMRTP2R.js → chunk-TFFOK3SJ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SkillError
-} from "./chunk-EB5V6K5E.js";
+} from "./chunk-4X3MIKOZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-S2467S6L.js";

package/chunks/{chunk-OD2XVV6S.js → chunk-TJRZBOWB.js}

@@ -2,22 +2,22 @@
 "use strict";
 import {
   JsonFormatter
-} from "./chunk-A4JNI44O.js";
+} from "./chunk-AKIPIOIW.js";
 import {
   parseAndFormatApiError
-} from "./chunk-KRZBFGAT.js";
+} from "./chunk-32XL2YY2.js";
 import {
   stripAnsiAndControl
 } from "./chunk-FKI7XUZK.js";
-import {
-  createDebugLogger
-} from "./chunk-UK2KIU2V.js";
 import {
   runExitCleanup
-} from "./chunk-7H7YR3TX.js";
+} from "./chunk-VSGHHI2A.js";
 import {
   writeStderrLine
 } from "./chunk-RANA4SOY.js";
+import {
+  createDebugLogger
+} from "./chunk-UK2KIU2V.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,

package/chunks/chunk-TL23ZRID.js

@@ -0,0 +1,327 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  fetchWithPolicy
+} from "./chunk-TC2TJAOF.js";
+import {
+  applyDynamicHeaderValues,
+  hasDynamicPlaceholder,
+  warnIfDynamicHeadersDisabled
+} from "./chunk-TPHHBX2V.js";
+import {
+  BRAND,
+  ORGANIZAONE_CLIENT_HEADERS
+} from "./chunk-IKYYF5PP.js";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/outbound-fetch.ts
+init_esbuild_shims();
+
+// packages/core/src/providers/organizaone-limits.ts
+init_esbuild_shims();
+
+// packages/core/src/providers/client-identity.ts
+init_esbuild_shims();
+function o1CodeUserAgent(version) {
+  return `${BRAND.userAgent}/${version || "unknown"} (${process.platform}; ${process.arch})`;
+}
+__name(o1CodeUserAgent, "o1CodeUserAgent");
+
+// packages/core/src/providers/organizaone-limits.ts
+var KEY_TIMEOUT_MS = 5e3;
+var KEY_MAX_BYTES = 256 * 1024;
+var DURATION_PART = /(\d+(?:\.\d+)?)(ms|h|m|s)/g;
+var DURATION = /^(?:\d+(?:\.\d+)?(?:ms|h|m|s))+$/;
+var UNIT_MS = {
+  h: 36e5,
+  m: 6e4,
+  s: 1e3,
+  ms: 1
+};
+function parseLimitResetDuration(value) {
+  const text = value.trim();
+  if (!DURATION.test(text)) return void 0;
+  let total = 0;
+  for (const [, amount, unit] of text.matchAll(DURATION_PART)) {
+    total += Number(amount) * UNIT_MS[unit];
+  }
+  return Math.round(total);
+}
+__name(parseLimitResetDuration, "parseLimitResetDuration");
+function nonNegativeInteger(value) {
+  if (value === null || !/^\d+$/.test(value.trim())) return void 0;
+  return Number(value.trim());
+}
+__name(nonNegativeInteger, "nonNegativeInteger");
+function readWindow(headers, kind) {
+  const limit = nonNegativeInteger(headers.get(`x-ratelimit-limit-${kind}`));
+  const remaining = nonNegativeInteger(
+    headers.get(`x-ratelimit-remaining-${kind}`)
+  );
+  if (limit === void 0 || remaining === void 0) return void 0;
+  const reset = headers.get(`x-ratelimit-reset-${kind}`);
+  const resetMs = reset === null ? void 0 : parseLimitResetDuration(reset);
+  return { limit, remaining, ...resetMs === void 0 ? {} : { resetMs } };
+}
+__name(readWindow, "readWindow");
+function readRateLimitHeaders(headers, now = Date.now()) {
+  const requests = readWindow(headers, "requests");
+  const tokens = readWindow(headers, "tokens");
+  if (!requests && !tokens) return null;
+  return {
+    ...requests ? { requests } : {},
+    ...tokens ? { tokens } : {},
+    at: now
+  };
+}
+__name(readRateLimitHeaders, "readRateLimitHeaders");
+function isLowWindow(window) {
+  if (window.limit <= 0) return false;
+  return window.remaining <= Math.max(1, Math.ceil(window.limit * 0.1));
+}
+__name(isLowWindow, "isLowWindow");
+var latest;
+var warned = /* @__PURE__ */ new Set();
+var listeners = /* @__PURE__ */ new Set();
+function recordRateLimitHeaders(headers, now = Date.now()) {
+  const snapshot = readRateLimitHeaders(headers, now);
+  if (!snapshot) return;
+  latest = snapshot;
+  for (const kind of ["requests", "tokens"]) {
+    const window = snapshot[kind];
+    if (!window) continue;
+    if (!isLowWindow(window)) {
+      warned.delete(kind);
+      continue;
+    }
+    if (warned.has(kind)) continue;
+    warned.add(kind);
+    for (const listener of listeners) {
+      try {
+        listener({ kind, ...window });
+      } catch {
+      }
+    }
+  }
+}
+__name(recordRateLimitHeaders, "recordRateLimitHeaders");
+function getLatestRateLimits() {
+  return latest;
+}
+__name(getLatestRateLimits, "getLatestRateLimits");
+function onLowRateLimit(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+__name(onLowRateLimit, "onLowRateLimit");
+var KEY_LIMIT_USAGE = {
+  requests_per_minute: "requests_this_minute",
+  tokens_per_minute: "tokens_this_minute",
+  requests_per_day: "requests_today",
+  tokens_per_day: "tokens_today",
+  concurrent: "in_flight",
+  spend_per_day_micros: "spend_today_micros",
+  spend_per_month_micros: "spend_this_month_micros"
+};
+var OWN_CAP_USAGE = {
+  requests_per_minute: "rpm",
+  requests_per_day: "rpd",
+  tokens_per_day: "tpd",
+  concurrent: "concurrent"
+};
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function str(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+__name(str, "str");
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(num, "num");
+function numOrNull(value) {
+  return num(value) ?? null;
+}
+__name(numOrNull, "numOrNull");
+function limitValues(value) {
+  if (!isRecord(value)) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === null) out[key] = null;
+    else if (num(entry) !== void 0) out[key] = entry;
+  }
+  return out;
+}
+__name(limitValues, "limitValues");
+function usageValues(value) {
+  if (!isRecord(value)) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const n = num(entry);
+    if (n !== void 0) out[key] = n;
+  }
+  return out;
+}
+__name(usageValues, "usageValues");
+function readPlan(value) {
+  if (!isRecord(value)) return null;
+  const period = isRecord(value["period"]) ? value["period"] : void 0;
+  const allowances = isRecord(value["allowances"]) ? value["allowances"] : void 0;
+  const spend = isRecord(allowances?.["spend"]) ? allowances["spend"] : void 0;
+  const used = num(spend?.["used"]);
+  return {
+    ...str(value["name"]) ? { name: str(value["name"]) } : {},
+    ...str(period?.["end"]) ? { periodEnd: str(period?.["end"]) } : {},
+    ...spend && used !== void 0 ? {
+      spend: {
+        included: numOrNull(spend["included"]),
+        used,
+        remaining: numOrNull(spend["remaining"]),
+        ...str(spend["overage"]) ? { overage: str(spend["overage"]) } : {}
+      }
+    } : {},
+    ceilingMicros: numOrNull(value["ceiling_micros"]),
+    maxOutputTokens: numOrNull(value["max_output_tokens"])
+  };
+}
+__name(readPlan, "readPlan");
+function parseKeyInfo(body) {
+  if (!isRecord(body) || !isRecord(body["data"])) return null;
+  const data = body["data"];
+  const limits = isRecord(data["limits"]) ? data["limits"] : void 0;
+  const rawScopes = limits?.["scopes"];
+  if (!Array.isArray(rawScopes)) return null;
+  const scopes = [];
+  for (const entry of rawScopes) {
+    if (!isRecord(entry) || !str(entry["scope"])) continue;
+    scopes.push({
+      scope: entry["scope"],
+      limits: limitValues(entry["limits"]),
+      usage: usageValues(entry["usage"])
+    });
+  }
+  const device = isRecord(data["device"]) ? data["device"] : void 0;
+  const own = isRecord(data["own"]) ? data["own"] : void 0;
+  return {
+    ...device ? {
+      device: {
+        ...str(device["name"]) ? { name: str(device["name"]) } : {},
+        ...str(device["expires_at"]) ? { expiresAt: str(device["expires_at"]) } : {}
+      }
+    } : {},
+    ...str(limits?.["time_zone"]) ? { timeZone: str(limits?.["time_zone"]) } : {},
+    ...str(limits?.["day_reset"]) ? { dayReset: str(limits?.["day_reset"]) } : {},
+    ...str(limits?.["month_reset"]) ? { monthReset: str(limits?.["month_reset"]) } : {},
+    scopes,
+    plan: readPlan(data["plan"]),
+    own: own ? {
+      enabled: own["enabled"] === true,
+      caps: limitValues(own["caps"]),
+      usage: usageValues(own["usage"])
+    } : null
+  };
+}
+__name(parseKeyInfo, "parseKeyInfo");
+function keyInfoUrl(baseUrl) {
+  return `${baseUrl.trim().replace(/\/+$/, "").replace(/\/v1$/, "")}/v1/key`;
+}
+__name(keyInfoUrl, "keyInfoUrl");
+async function fetchKeyInfo({
+  baseUrl,
+  apiKey,
+  signal,
+  clientVersion
+}) {
+  if (!baseUrl.trim() || !apiKey.trim()) return null;
+  try {
+    const result = await fetchWithPolicy(keyInfoUrl(baseUrl), {
+      timeoutMs: KEY_TIMEOUT_MS,
+      maxBytes: KEY_MAX_BYTES,
+      maxRedirects: 2,
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey.trim()}`,
+        "User-Agent": o1CodeUserAgent(clientVersion),
+        ...ORGANIZAONE_CLIENT_HEADERS
+      },
+      signal
+    });
+    if (result.kind !== "response" || result.status < 200 || result.status >= 300) {
+      return null;
+    }
+    return parseKeyInfo(JSON.parse(result.body.toString("utf8")));
+  } catch {
+    return null;
+  }
+}
+__name(fetchKeyInfo, "fetchKeyInfo");
+
+// packages/core/src/core/outbound-fetch.ts
+function wrapFetchWithDynamicHeaders(baseFetch, config, customHeaders) {
+  const fetchLike = baseFetch;
+  const expandsHeaders = Object.values(customHeaders ?? {}).some(
+    (value) => typeof value === "string" && hasDynamicPlaceholder(value)
+  );
+  if (expandsHeaders) warnIfDynamicHeadersDisabled(customHeaders, config);
+  const wrapped = /* @__PURE__ */ __name(async (input, init) => {
+    if (!expandsHeaders) return fetchLike(input, init);
+    const headers = new Headers(
+      input instanceof Request ? input.headers : void 0
+    );
+    new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
+    applyDynamicHeaderValues(headers, config);
+    return fetchLike(input, { ...init, headers });
+  }, "wrapped");
+  return wrapped;
+}
+__name(wrapFetchWithDynamicHeaders, "wrapFetchWithDynamicHeaders");
+function buildOutboundFetch(runtimeFetch, config, customHeaders, options = {}) {
+  const baseFetch = runtimeFetch ?? globalThis.fetch;
+  const wrapped = wrapFetchWithDynamicHeaders(baseFetch, config, customHeaders);
+  if (!options.recordRateLimits) return wrapped;
+  const recording = /* @__PURE__ */ __name(async (input, init) => {
+    const response = await wrapped(input, init);
+    recordRateLimitHeaders(response.headers);
+    return response;
+  }, "recording");
+  return recording;
+}
+__name(buildOutboundFetch, "buildOutboundFetch");
+
+export {
+  o1CodeUserAgent,
+  getLatestRateLimits,
+  onLowRateLimit,
+  KEY_LIMIT_USAGE,
+  OWN_CAP_USAGE,
+  fetchKeyInfo,
+  buildOutboundFetch
+};
+/**
+ * @license
+ * Copyright 2026 o1-code contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 o1-code contributors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * What the OrganizaOne proxy says about the key's limits (contract §3.5):
+ * `GET /v1/key` on demand, and OpenAI's `x-ratelimit-*` headers on every
+ * admitted request, which name the account's tightest windows.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-QMCDBQRJ.js → chunk-TP3M5WJ2.js}

@@ -3,7 +3,7 @@
 import {
   require_src as require_src2,
   require_src3
-} from "./chunk-MDU4BZLN.js";
+} from "./chunk-YSZCVSC3.js";
 import {
   require_src
 } from "./chunk-EPSJPAHV.js";