@organizaone/o1-code 0.11.3 → 0.13.0

package/chunks/{chunk-5V3EOW36.js → chunk-SGPBAZXG.js}

@@ -14,27 +14,41 @@ import {
   estimateRawResourceTokens,
   runFixedPolicies,
   runOmniGcOnce
-} from "./chunk-EIJNDD2V.js";
+} from "./chunk-JM5VEUJJ.js";
 import {
   MEDIA_DETECTOR_VERSION,
   MediaMemoryService
 } from "./chunk-DM6W2QYB.js";
-import {
-  runStartupRecoveryOnce
-} from "./chunk-GVWQRVLV.js";
 import {
   resolveNetworkTarget
 } from "./chunk-HPQNI3OQ.js";
-import {
-  isPermittedRedirect,
-  isPrivateHost
-} from "./chunk-ALIO4STD.js";
 import {
   isOmniDeliveryActive
-} from "./chunk-HK7AV2JH.js";
+} from "./chunk-NRL7UTKJ.js";
 import {
   requireEffectiveOmniUploadConfig
-} from "./chunk-ZBV6TO3P.js";
+} from "./chunk-T44PDHSJ.js";
+import {
+  runStartupRecoveryOnce
+} from "./chunk-GVWQRVLV.js";
+import {
+  DEFAULT_UPLOAD_CACHE_TTL_HOURS,
+  OmniUploadCache
+} from "./chunk-CZWW4DCB.js";
+import {
+  OmniObjectStore,
+  prepareOmniDownloadsDir
+} from "./chunk-ETGSZYWP.js";
+import {
+  extensionForMime,
+  hashFileSha256,
+  recognizeMediaFile,
+  sniffMediaType
+} from "./chunk-RCZHQZJJ.js";
+import {
+  isFfmpegAvailable,
+  isFfprobeAvailable
+} from "./chunk-6YS3YH6O.js";
 import {
   OMNI_DISCLOSURE_TEXT_PREFIX,
   OMNI_OMISSION_TEXT_PREFIX,
@@ -52,6 +66,10 @@ import {
   splitAnnotationBody,
   unescapeAnnotationName
 } from "./chunk-HX6AICAX.js";
+import {
+  isPermittedRedirect,
+  isPrivateHost
+} from "./chunk-TC2TJAOF.js";
 import {
   TOOL_RESULT_MEDIA_REMEDY,
   clampInlineMediaPart,
@@ -66,24 +84,6 @@ import {
   detectRuntime,
   loadUndici
 } from "./chunk-HDGYCLNB.js";
-import {
-  DEFAULT_UPLOAD_CACHE_TTL_HOURS,
-  OmniUploadCache
-} from "./chunk-CZWW4DCB.js";
-import {
-  OmniObjectStore,
-  prepareOmniDownloadsDir
-} from "./chunk-ETGSZYWP.js";
-import {
-  extensionForMime,
-  hashFileSha256,
-  recognizeMediaFile,
-  sniffMediaType
-} from "./chunk-RCZHQZJJ.js";
-import {
-  isFfmpegAvailable,
-  isFfprobeAvailable
-} from "./chunk-6YS3YH6O.js";
 import {
   createDebugLogger
 } from "./chunk-UK2KIU2V.js";

package/chunks/{chunk-ER3EHNTV.js → chunk-SPTU3FVH.js}

@@ -3,6 +3,9 @@
 import {
   stripAnsiAndControl
 } from "./chunk-FKI7XUZK.js";
+import {
+  require_src
+} from "./chunk-EPSJPAHV.js";
 import {
   createDebugLogger,
   getCurrentSessionId,
@@ -12,9 +15,6 @@ import {
   setSessionIdOnContext,
   setShellTracePropagation
 } from "./chunk-UK2KIU2V.js";
-import {
-  require_src
-} from "./chunk-EPSJPAHV.js";
 import {
   DiagLogLevel,
   ROOT_CONTEXT,
@@ -1224,7 +1224,7 @@ function initializeTelemetry(config) {
   telemetryInitPromise ??= (async () => {
     const debugLogger3 = createDebugLogger("OTEL");
     try {
-      const { startTelemetrySdk } = await import("./sdk-impl-G2NWB5MF.js");
+      const { startTelemetrySdk } = await import("./sdk-impl-5PWLMFPQ.js");
       if (telemetryInitialized) return;
       const started = await startTelemetrySdk(config);
       if (!started) return;

package/chunks/chunk-SYFWO6RZ.js

@@ -0,0 +1,372 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  ALL_PROVIDERS
+} from "./chunk-TZSB5TBL.js";
+import {
+  REASONING_EFFORT_TIERS,
+  clampReasoningEffort,
+  getGptReasoningCapabilities,
+  normalize,
+  parseModelReasoningCapabilities
+} from "./chunk-72EBG4FJ.js";
+import {
+  createDebugLogger
+} from "./chunk-UK2KIU2V.js";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/reasoning-overrides.ts
+init_esbuild_shims();
+
+// packages/core/src/core/openaiContentGenerator/provider/openrouter.ts
+init_esbuild_shims();
+function isOpenRouterHostname(contentGeneratorConfig) {
+  const baseUrl = contentGeneratorConfig.baseUrl ?? "";
+  if (!baseUrl) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    return hostname === "openrouter.ai" || hostname.endsWith(".openrouter.ai");
+  } catch {
+    return false;
+  }
+}
+__name(isOpenRouterHostname, "isOpenRouterHostname");
+
+// packages/core/src/core/anthropic-reasoning.ts
+init_esbuild_shims();
+var CLAUDE_MODEL_FAMILIES = [
+  "opus",
+  "sonnet",
+  "haiku",
+  "fable",
+  "mythos"
+];
+function parseClaudeModelVersion(model) {
+  const match = model.toLowerCase().match(
+    new RegExp(
+      `claude-(${CLAUDE_MODEL_FAMILIES.join(
+        "|"
+      )})-(\\d+)(?:[-.](\\d{1,2})(?!\\d))?`
+    )
+  );
+  if (!match) {
+    return null;
+  }
+  return {
+    family: match[1],
+    major: Number.parseInt(match[2], 10),
+    minor: match[3] ? Number.parseInt(match[3], 10) : 0
+  };
+}
+__name(parseClaudeModelVersion, "parseClaudeModelVersion");
+function anthropicSupportedEffortTiers(model) {
+  const tiers = ["low", "medium", "high"];
+  const parsed = parseClaudeModelVersion(model);
+  if (!parsed) {
+    return tiers;
+  }
+  const { family, major, minor } = parsed;
+  const atLeast = /* @__PURE__ */ __name((maj, min) => major > maj || major === maj && minor >= min, "atLeast");
+  if (major >= 5 || family === "opus" && atLeast(4, 7)) {
+    tiers.push("xhigh");
+  }
+  if (major >= 5 || (family === "opus" || family === "sonnet") && atLeast(4, 6)) {
+    tiers.push("max");
+  }
+  return tiers;
+}
+__name(anthropicSupportedEffortTiers, "anthropicSupportedEffortTiers");
+
+// packages/core/src/core/reasoning-overrides.ts
+var REASONING_PROFILES = [
+  "openai-effort",
+  "openai-reasoning",
+  "deepseek-openai",
+  "dashscope-effort",
+  "dashscope-thinking",
+  "chat-template-thinking",
+  "anthropic-manual",
+  "anthropic-adaptive",
+  "deepseek-anthropic",
+  "gemini"
+];
+function invalidReasoning(route) {
+  throw new Error(
+    `Model "${route.model}" capabilities.reasoning: invalid profile, efforts or defaultEffort`
+  );
+}
+__name(invalidReasoning, "invalidReasoning");
+function validateReasoningDeclaration(route, declaration) {
+  if (declaration === void 0) return void 0;
+  if (!declaration || typeof declaration !== "object" || Array.isArray(declaration))
+    return invalidReasoning(route);
+  const input = declaration;
+  if (input.profile === void 0 && ("thinking" in input || "disableField" in input))
+    return parseModelReasoningCapabilities(input);
+  if (!Object.keys(input).length || Object.keys(input).some(
+    (key) => ![
+      "profile",
+      "efforts",
+      "defaultEffort",
+      "thinking",
+      "toggleOnly",
+      "canDisable",
+      "disableField"
+    ].includes(key)
+  ))
+    return invalidReasoning(route);
+  if (input.profile !== void 0 && !REASONING_PROFILES.includes(input.profile) || input.thinking !== void 0 && input.thinking !== true || input.toggleOnly !== void 0 && typeof input.toggleOnly !== "boolean" || input.canDisable !== void 0 && input.canDisable !== false)
+    return invalidReasoning(route);
+  if (input.efforts !== void 0 && (!Array.isArray(input.efforts) || !input.efforts.length || input.efforts.some((tier) => !REASONING_EFFORT_TIERS.includes(tier)) || new Set(input.efforts).size !== input.efforts.length))
+    return invalidReasoning(route);
+  if (input.defaultEffort !== void 0 && (!REASONING_EFFORT_TIERS.includes(input.defaultEffort) || input.efforts && !input.efforts.includes(input.defaultEffort)))
+    return invalidReasoning(route);
+  return input;
+}
+__name(validateReasoningDeclaration, "validateReasoningDeclaration");
+function resolveReasoningCapabilities(route, declaration) {
+  try {
+    return validateReasoningCapabilities(route, declaration);
+  } catch {
+    return void 0;
+  }
+}
+__name(resolveReasoningCapabilities, "resolveReasoningCapabilities");
+function validateReasoningCapabilities(route, declaration) {
+  const input = validateReasoningDeclaration(route, declaration);
+  if (!input) return void 0;
+  if (input.profile === void 0 && "thinking" in input)
+    return parseModelReasoningCapabilities(input);
+  const model = normalize(route.model);
+  const provider = ALL_PROVIDERS.find(
+    (candidate) => typeof candidate.baseUrl === "string" ? candidate.baseUrl === route.baseUrl : candidate.baseUrl?.some((option) => option.url === route.baseUrl)
+  );
+  const known = (provider?.models?.find((candidate) => candidate.id === route.model) ?? provider?.models?.find((candidate) => candidate.id === model))?.capabilities?.reasoning;
+  const inherited = parseModelReasoningCapabilities(known);
+  if (!input.profile && inherited?.toggleOnly) {
+    if (input.efforts || input.defaultEffort) return invalidReasoning(route);
+    return parseModelReasoningCapabilities({ ...inherited, ...input });
+  }
+  const gpt = getGptReasoningCapabilities(route.model);
+  const claude = route.authType === "anthropic" ? parseClaudeModelVersion(route.model) : void 0;
+  if (!inherited && !gpt && !claude && !input.profile)
+    return invalidReasoning(route);
+  const auth = route.authType;
+  let host = "";
+  try {
+    host = new URL(route.baseUrl ?? "").hostname.toLowerCase();
+  } catch {
+    host = "";
+  }
+  const dashscope = /(^|\.)(dashscope(?:-intl|-us)?\.aliyuncs\.com|alicloudapi\.com)$/.test(
+    host
+  ) || /^token-plan\..+\.maas\.aliyuncs\.com$/.test(host);
+  const profile = input.profile ?? (auth === "gemini" || auth === "vertex-ai" ? "gemini" : auth === "openai-responses" ? "openai-reasoning" : auth === "openai" && isOpenRouterHostname(route) ? "openai-reasoning" : auth === "anthropic" ? model.includes("deepseek") ? "deepseek-anthropic" : claude && (claude.major > 4 || claude.major === 4 && claude.minor >= 6) ? "anthropic-adaptive" : "anthropic-manual" : model.startsWith("qwen") ? dashscope ? inherited?.disableField === "reasoning_effort" ? "dashscope-effort" : "dashscope-thinking" : "chat-template-thinking" : inherited?.disableField === "thinking" ? "deepseek-openai" : "openai-effort");
+  const protocol = profile === "gemini" ? "gemini" : profile.startsWith("anthropic-") || profile === "deepseek-anthropic" ? "anthropic" : "openai";
+  if (auth === "openai-responses" && profile !== "openai-reasoning" || auth && protocol !== (auth === "vertex-ai" ? "gemini" : auth === "openai-responses" ? "openai" : auth))
+    return invalidReasoning(route);
+  const toggleOnly = profile === "dashscope-thinking" || profile === "chat-template-thinking";
+  const disableField = !input.profile && inherited?.disableField || (toggleOnly ? "enable_thinking" : profile === "openai-effort" || profile === "dashscope-effort" ? "reasoning_effort" : "thinking");
+  const inheritedEfforts = inherited && !inherited.toggleOnly ? inherited.efforts : gpt?.efforts ?? (claude ? anthropicSupportedEffortTiers(route.model) : void 0);
+  const efforts = input.efforts ?? inheritedEfforts;
+  const inheritedDefault = inherited && !inherited.toggleOnly ? inherited.defaultEffort : gpt?.defaultEffort;
+  const defaultEffort = input.defaultEffort ?? (inheritedDefault && efforts ? clampReasoningEffort(inheritedDefault, efforts) : void 0);
+  if (toggleOnly && (input.efforts !== void 0 || input.defaultEffort !== void 0) || !toggleOnly && (!efforts || !defaultEffort) || profile === "gemini" && efforts?.some((tier) => tier === "xhigh" || tier === "max"))
+    return invalidReasoning(route);
+  const result = {
+    ...input,
+    thinking: true,
+    profile,
+    toggleOnly,
+    disableField,
+    ...toggleOnly ? {} : { efforts, defaultEffort },
+    ...route.thinkingMandatory || inherited?.canDisable === false || gpt?.thinkingMandatory ? { canDisable: false } : {}
+  };
+  const parsed = parseModelReasoningCapabilities(result);
+  if (!parsed) return invalidReasoning(route);
+  return {
+    ...parsed,
+    profile,
+    ...gpt && input.defaultEffort === void 0 ? { defaultEnabled: gpt.defaultEnabled } : {}
+  };
+}
+__name(validateReasoningCapabilities, "validateReasoningCapabilities");
+function captureReasoningSnapshot(models) {
+  return Object.freeze(
+    models.map(
+      (model) => Object.freeze({
+        id: model.id,
+        authType: model.authType,
+        baseUrl: model.baseUrl,
+        registryBaseUrl: model.registryBaseUrl,
+        reasoning: model.capabilities?.reasoning && typeof model.capabilities.reasoning === "object" ? Object.freeze({
+          ...structuredClone(model.capabilities.reasoning),
+          ..."efforts" in model.capabilities.reasoning && Array.isArray(model.capabilities.reasoning.efforts) ? {
+            efforts: Object.freeze([
+              ...model.capabilities.reasoning.efforts
+            ])
+          } : {}
+        }) : model.capabilities?.reasoning
+      })
+    )
+  );
+}
+__name(captureReasoningSnapshot, "captureReasoningSnapshot");
+function resolveReasoningForModel(config, generation, model = generation.model, strict = false) {
+  let declaration;
+  if (generation.reasoningSnapshot) {
+    const rows = generation.reasoningSnapshot.filter(
+      (row2) => row2.authType === generation.authType && row2.id === model
+    );
+    const row = generation.reasoningRouteBaseUrl === null && model === generation.model ? rows.find((row2) => row2.registryBaseUrl === void 0) : typeof generation.reasoningRouteBaseUrl === "string" && model === generation.model ? rows.find(
+      (row2) => row2.registryBaseUrl === generation.reasoningRouteBaseUrl
+    ) : rows.find((row2) => row2.registryBaseUrl === generation.baseUrl) ?? rows.find(
+      (row2) => row2.registryBaseUrl === void 0 && row2.baseUrl === generation.baseUrl
+    );
+    declaration = row?.reasoning;
+  } else {
+    declaration = generation.authType ? config?.getResolvedModelConfig?.(
+      generation.authType,
+      model,
+      generation.baseUrl
+    )?.capabilities?.reasoning : void 0;
+  }
+  return (strict ? validateReasoningCapabilities : resolveReasoningCapabilities)(
+    {
+      ...generation,
+      model,
+      thinkingMandatory: model === generation.model ? generation.thinkingMandatory : void 0
+    },
+    declaration
+  );
+}
+__name(resolveReasoningForModel, "resolveReasoningForModel");
+function getEffectiveReasoning(generation, resolved) {
+  if (!resolved) return generation.reasoning;
+  if (generation.reasoning === false && resolved.canDisable !== false)
+    return false;
+  const selected = generation.reasoning || void 0;
+  if (!selected && resolved.defaultEnabled === false && resolved.canDisable !== false)
+    return false;
+  if (resolved.toggleOnly)
+    return selected ?? (resolved.profile ? {} : void 0);
+  const effort = selected?.effort ?? resolved.defaultEffort;
+  return effort ? {
+    ...selected,
+    effort: resolved.profile && REASONING_EFFORT_TIERS.includes(effort) ? clampReasoningEffort(effort, resolved.efforts) : effort
+  } : selected;
+}
+__name(getEffectiveReasoning, "getEffectiveReasoning");
+
+// packages/core/src/core/outbound-dynamic-headers.ts
+init_esbuild_shims();
+var debugLogger = createDebugLogger("OUTBOUND_CORRELATION");
+var PLACEHOLDERS = [{ token: "${session_id}", resolve: /* @__PURE__ */ __name((config) => config.getSessionId(), "resolve") }];
+var SESSION_ID_PLACEHOLDER_PATTERN = /\$(?:session_id|O1CODE_SESSION_ID)(?!\w)|\$\{(?:session_id|O1CODE_SESSION_ID)\}/gi;
+var warnedGateOff = /* @__PURE__ */ new Set();
+function warnIfDynamicHeadersDisabled(customHeaders, config) {
+  try {
+    const names = Object.entries(customHeaders ?? {}).filter(
+      ([, value]) => typeof value === "string" && hasDynamicPlaceholder(value)
+    ).map(([name]) => name);
+    if (names.length === 0) return;
+    if (config.getOutboundAllowDynamicHeaderValues()) return;
+    const key = names.slice().sort().join(",");
+    if (warnedGateOff.has(key)) return;
+    warnedGateOff.add(key);
+    console.warn(
+      `customHeaders ${names.join(", ")} contain a runtime placeholder, but outboundCorrelation.allowDynamicHeaderValues is not enabled \u2014 the header(s) will not be sent. Set it to true in settings.json to allow the value to be filled in per request.`
+    );
+  } catch {
+  }
+}
+__name(warnIfDynamicHeadersDisabled, "warnIfDynamicHeadersDisabled");
+function hasDynamicPlaceholder(value) {
+  return value.search(SESSION_ID_PLACEHOLDER_PATTERN) !== -1;
+}
+__name(hasDynamicPlaceholder, "hasDynamicPlaceholder");
+function resolveDynamicHeaderValue(value, config) {
+  if (typeof value !== "string") return void 0;
+  if (!hasDynamicPlaceholder(value)) return value;
+  try {
+    if (!config.getOutboundAllowDynamicHeaderValues()) {
+      debugLogger.warn(
+        `Dropping a customHeaders value containing a runtime placeholder: outboundCorrelation.allowDynamicHeaderValues is not enabled.`
+      );
+      return void 0;
+    }
+    let expanded = value.replace(
+      SESSION_ID_PLACEHOLDER_PATTERN,
+      "${session_id}"
+    );
+    for (const { token, resolve } of PLACEHOLDERS) {
+      if (!expanded.includes(token)) continue;
+      const resolved = resolve(config);
+      if (!resolved) return void 0;
+      expanded = expanded.split(token).join(resolved);
+    }
+    return expanded;
+  } catch (error) {
+    debugLogger.warn(
+      `Unable to expand a customHeaders placeholder: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+}
+__name(resolveDynamicHeaderValue, "resolveDynamicHeaderValue");
+function applyDynamicHeaderValues(headers, config) {
+  const pending = [];
+  headers.forEach((value, key) => {
+    if (hasDynamicPlaceholder(value)) pending.push([key, value]);
+  });
+  for (const [key, value] of pending) {
+    const resolved = resolveDynamicHeaderValue(value, config);
+    if (resolved === void 0) {
+      headers.delete(key);
+    } else {
+      headers.set(key, resolved);
+    }
+  }
+}
+__name(applyDynamicHeaderValues, "applyDynamicHeaderValues");
+function expandDynamicHeaders(customHeaders, config) {
+  if (!customHeaders) return {};
+  const expanded = {};
+  for (const [key, value] of Object.entries(customHeaders)) {
+    if (typeof value !== "string" || !hasDynamicPlaceholder(value)) continue;
+    const resolved = resolveDynamicHeaderValue(value, config);
+    if (resolved !== void 0) expanded[key] = resolved;
+  }
+  return expanded;
+}
+__name(expandDynamicHeaders, "expandDynamicHeaders");
+
+export {
+  isOpenRouterHostname,
+  parseClaudeModelVersion,
+  anthropicSupportedEffortTiers,
+  resolveReasoningCapabilities,
+  validateReasoningCapabilities,
+  captureReasoningSnapshot,
+  resolveReasoningForModel,
+  getEffectiveReasoning,
+  warnIfDynamicHeadersDisabled,
+  hasDynamicPlaceholder,
+  applyDynamicHeaderValues,
+  expandDynamicHeaders
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-ZBV6TO3P.js → chunk-T44PDHSJ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   DashScopeOpenAICompatibleProvider
-} from "./chunk-UDWKKKF3.js";
+} from "./chunk-LBLYCZ66.js";
 import {
   init_esbuild_shims
 } from "./chunk-S2467S6L.js";