@organizaone/o1-code 0.20.0 → 0.20.1

package/chunks/{chunk-DHERIROV.js → chunk-2UDEKBYA.js}

@@ -1,32 +1,5 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  CompactToolGroupDisplay,
-  ICON,
-  SCREEN_READER_MODEL_PREFIX,
-  SCREEN_READER_USER_PREFIX,
-  SHELL_COMMAND_NAME,
-  SHELL_NAME,
-  STATUS_INDICATOR_WIDTH,
-  Spinner,
-  ToolElapsedTime,
-  ToolStatusIndicator,
-  buildResumedHistoryItems,
-  build_default,
-  coalesceFindingsHistoryItems,
-  estimateCompactToolGroupHeight,
-  getOverallStatus,
-  getToolCategory,
-  isCollapsibleTool,
-  isFindingsListDisplay,
-  showsToolLabel
-} from "./chunk-KGYXJDO6.js";
-import {
-  disableMouseEvents,
-  enableMouseEvents,
-  useKeypress,
-  useKeypressContext
-} from "./chunk-JMM2J43E.js";
 import {
   INLINE_CODE_SPAN_PATTERN_SOURCE,
   calculateAverageLatency,
@@ -48,27 +21,58 @@ import {
   readInlineMathSpanAt,
   unescapeMarkdownBeforeMath,
   unescapeMarkdownDollars
-} from "./chunk-PWDV5AMU.js";
-import {
-  formatDuration,
-  formatRelativeTime,
-  formatTokenCount
-} from "./chunk-PUL422GV.js";
-import {
-  TOP_FRAME,
-  glyphs
-} from "./chunk-U6ZAL4MF.js";
+} from "./chunk-CCW6IQGJ.js";
 import {
   MINIMUM_MAX_HEIGHT,
   MaxSizedBox
 } from "./chunk-DSAFH5CY.js";
+import {
+  CompactToolGroupDisplay,
+  ICON,
+  SCREEN_READER_MODEL_PREFIX,
+  SCREEN_READER_USER_PREFIX,
+  SHELL_COMMAND_NAME,
+  SHELL_NAME,
+  STATUS_INDICATOR_WIDTH,
+  Spinner,
+  ToolElapsedTime,
+  ToolStatusIndicator,
+  buildResumedHistoryItems,
+  build_default,
+  coalesceFindingsHistoryItems,
+  estimateCompactToolGroupHeight,
+  getOverallStatus,
+  getToolCategory,
+  isCollapsibleTool,
+  isFindingsListDisplay,
+  showsToolLabel
+} from "./chunk-JXHE3Q7W.js";
+import {
+  formatDuration,
+  formatRelativeTime,
+  formatTokenCount
+} from "./chunk-BP4CPYAM.js";
 import {
   extendedTheme,
   theme
 } from "./chunk-NTUVIB2G.js";
+import {
+  disableMouseEvents,
+  enableMouseEvents,
+  useKeypress,
+  useKeypressContext
+} from "./chunk-ULFANPGF.js";
 import {
   require_jsx_runtime
 } from "./chunk-SKTOH6US.js";
+import {
+  resolveColor,
+  themeManager
+} from "./chunk-VFSP4ZUZ.js";
+import {
+  TOP_FRAME,
+  glyphs
+} from "./chunk-U6ZAL4MF.js";
 import {
   Box_default,
   Static,
@@ -94,19 +98,15 @@ import {
 import {
   formatInlineImageOverflow
 } from "./chunk-KIN34HCU.js";
-import {
-  resolveColor,
-  themeManager
-} from "./chunk-VFSP4ZUZ.js";
 import {
   require_source
 } from "./chunk-XZ3MQL2U.js";
 import {
   getErrorMessage
-} from "./chunk-JZZN42BL.js";
+} from "./chunk-VCYXTJKE.js";
 import {
   relaunchApp
-} from "./chunk-PXRDPUM6.js";
+} from "./chunk-DV7OATUZ.js";
 import {
   cpLen,
   cpSlice,
@@ -125,23 +125,23 @@ import {
 } from "./chunk-F5IN4KK7.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-NFNJSERR.js";
+} from "./chunk-KT4SJM3N.js";
 import {
   getPersistScopeForModelSelection
-} from "./chunk-N343WURR.js";
+} from "./chunk-HCD2C6MU.js";
 import {
   getCurrentLanguage,
   localizeToolDisplayName,
   t
-} from "./chunk-6BOPO2CB.js";
+} from "./chunk-QFGPKAOX.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-TW633LAC.js";
+} from "./chunk-YMZWUG55.js";
 import {
   sanitizeForOsc,
   supportsHyperlinks,
   wrapForMultiplexer
-} from "./chunk-ACYDX6SG.js";
+} from "./chunk-VHFC6CDB.js";
 import {
   IdeClient,
   allowEditorTypeInSandbox,
@@ -151,10 +151,10 @@ import {
   ideContextStore,
   isEditorAvailable,
   isValidEditorType
-} from "./chunk-VGPRZT2M.js";
+} from "./chunk-T4WPMWU4.js";
 import {
   ShellExecutionService
-} from "./chunk-KICY6OQ7.js";
+} from "./chunk-PHCY2DQ2.js";
 import {
   stripAnsi
 } from "./chunk-WU3R2YUE.js";
@@ -170,7 +170,7 @@ import {
   getMCPServerStatus,
   isVisionBridgeNoticeDisplay,
   uiTelemetryService
-} from "./chunk-KBDFOYPK.js";
+} from "./chunk-ASQLIG2L.js";
 import {
   isTerminalImageDisplay
 } from "./chunk-JOFGX5ZA.js";
@@ -199,7 +199,7 @@ import {
   resolveMetadataKey,
   resolveOwnsModel,
   tryResolveModelProtocol
-} from "./chunk-I3YBDADP.js";
+} from "./chunk-D7DZAA5W.js";
 import {
   require_has_flag,
   require_supports_color

package/chunks/{chunk-A3JZZ2KW.js → chunk-3I7PGVYC.js}

@@ -75,7 +75,7 @@ async function runExitCleanupPass(options) {
 }
 __name(runExitCleanupPass, "runExitCleanupPass");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./deferred-core-runtime-HPHPB3AS.js");
+  const { Storage } = await import("./deferred-core-runtime-CJQCZJPG.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");

package/chunks/{chunk-UQXFYLTF.js → chunk-3K7BQWZY.js}

@@ -99,7 +99,7 @@ async function probeShellSandbox(policy, signal = new AbortController().signal)
   await mkdir(policy.state, { recursive: true, mode: 448 });
   if (realpathSync(policy.state) !== policy.state)
     throw new Error("Sandbox state directory changed after admission.");
-  const { executeBwrap } = await import("./bwrap-execution-32LOZ3PS.js");
+  const { executeBwrap } = await import("./bwrap-execution-A5QZJK2I.js");
   const handle = await executeBwrap(
     policy,
     {

package/chunks/{chunk-M4U4RIDA.js → chunk-3SCPHVRF.js}

@@ -16,14 +16,14 @@ import {
 } from "./chunk-MLAF3GLB.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-TW633LAC.js";
+} from "./chunk-YMZWUG55.js";
 import {
   require_main
 } from "./chunk-EYWIFUPJ.js";
 import {
   adoptExportedCredentialEnvKeys,
   exportedCredentialEnvKeys
-} from "./chunk-I3YBDADP.js";
+} from "./chunk-D7DZAA5W.js";
 import {
   writeStderrLineSafe
 } from "./chunk-RANA4SOY.js";

package/chunks/chunk-3UJ6A45H.js

@@ -0,0 +1,259 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/windows-clipboard.ts
+init_esbuild_shims();
+import { createRequire } from "node:module";
+import path from "node:path";
+var MAX_BYTES = 64 * 1024 * 1024;
+var MAX_PIXELS = 4e7;
+var PNG_SIGNATURE = Buffer.from("89504e470d0a1a0a", "hex");
+var native;
+function loadNative() {
+  const koffi = createRequire(import.meta.url)(
+    "koffi"
+  );
+  const root = process.env["SystemRoot"] || "C:\\Windows";
+  if (!path.win32.isAbsolute(root))
+    throw new Error("Invalid Windows SystemRoot");
+  const load = /* @__PURE__ */ __name((name) => koffi.load(path.win32.join(root, "System32", name)), "load");
+  const user = load("user32.dll");
+  const kernel = load("kernel32.dll");
+  return {
+    koffi,
+    load,
+    open: user.func("__stdcall", "OpenClipboard", "int", ["void *"]),
+    close: user.func("__stdcall", "CloseClipboard", "int", []),
+    available: user.func("__stdcall", "IsClipboardFormatAvailable", "int", [
+      "uint32_t"
+    ]),
+    get: user.func("__stdcall", "GetClipboardData", "void *", ["uint32_t"]),
+    png: user.func("__stdcall", "RegisterClipboardFormatW", "uint32_t", [
+      "str16"
+    ])("PNG"),
+    size: kernel.func("__stdcall", "GlobalSize", "size_t", ["void *"]),
+    lock: kernel.func("__stdcall", "GlobalLock", "void *", ["void *"]),
+    unlock: kernel.func("__stdcall", "GlobalUnlock", "int", ["void *"])
+  };
+}
+__name(loadNative, "loadNative");
+function api() {
+  native ??= loadNative();
+  if (!native.png) throw new Error("RegisterClipboardFormatW failed");
+  return native;
+}
+__name(api, "api");
+function withClipboard(read) {
+  const backend = api();
+  if (!backend.open(null)) throw new Error("OpenClipboard failed");
+  let result;
+  let closed;
+  try {
+    result = read(backend);
+  } finally {
+    closed = backend.close();
+  }
+  if (!closed) throw new Error("CloseClipboard failed");
+  return result;
+}
+__name(withClipboard, "withClipboard");
+function copyGlobal(backend, handle) {
+  if (!handle) throw new Error("GetClipboardData failed");
+  const size = Number(backend.size(handle));
+  if (!Number.isSafeInteger(size) || size <= 0 || size > MAX_BYTES) {
+    throw new Error("Clipboard allocation exceeds safe bounds");
+  }
+  const pointer = backend.lock(handle);
+  if (!pointer) throw new Error("GlobalLock failed");
+  try {
+    const bytes = new Uint8Array(backend.koffi.view(pointer, size));
+    if (bytes.length !== size)
+      throw new Error("Incomplete clipboard allocation");
+    return Buffer.from(bytes);
+  } finally {
+    backend.unlock(handle);
+  }
+}
+__name(copyGlobal, "copyGlobal");
+function checkDimensions(width, height) {
+  if (width <= 0 || height <= 0 || width * height > MAX_PIXELS) {
+    throw new Error("Clipboard image dimensions exceed safe bounds");
+  }
+}
+__name(checkDimensions, "checkDimensions");
+function trimPng(bytes) {
+  if (bytes.length < 45 || !bytes.subarray(0, 8).equals(PNG_SIGNATURE) || bytes.readUInt32BE(8) !== 13 || bytes.toString("ascii", 12, 16) !== "IHDR") {
+    throw new Error("Malformed clipboard PNG");
+  }
+  checkDimensions(bytes.readUInt32BE(16), bytes.readUInt32BE(20));
+  for (let offset = 8; offset + 12 <= bytes.length; ) {
+    const length = bytes.readUInt32BE(offset);
+    const end = offset + length + 12;
+    if (end > bytes.length) break;
+    if (bytes.toString("ascii", offset + 4, offset + 8) === "IEND") {
+      if (length !== 0) break;
+      return bytes.subarray(0, end);
+    }
+    offset = end;
+  }
+  throw new Error("Malformed clipboard PNG chunks");
+}
+__name(trimPng, "trimPng");
+function hasWindowsClipboardImage() {
+  if (process.platform !== "win32") return false;
+  const backend = api();
+  return Boolean(backend.available(backend.png) || backend.available(2));
+}
+__name(hasWindowsClipboardImage, "hasWindowsClipboardImage");
+function getWindowsClipboardText() {
+  if (process.platform !== "win32") return void 0;
+  return withClipboard((backend) => {
+    if (!backend.available(13)) return void 0;
+    const bytes = copyGlobal(backend, backend.get(13));
+    if (bytes.length % 2 !== 0)
+      throw new Error("Malformed clipboard UTF-16 text");
+    for (let offset = 0; offset < bytes.length; offset += 2) {
+      if (bytes.readUInt16LE(offset) === 0)
+        return bytes.toString("utf16le", 0, offset);
+    }
+    throw new Error("Unterminated clipboard UTF-16 text");
+  });
+}
+__name(getWindowsClipboardText, "getWindowsClipboardText");
+function getWindowsClipboardImage() {
+  if (process.platform !== "win32") return null;
+  return withClipboard((backend) => {
+    let pngFailure;
+    if (backend.available(backend.png)) {
+      try {
+        return trimPng(copyGlobal(backend, backend.get(backend.png)));
+      } catch (error) {
+        pngFailure = error;
+      }
+    }
+    if (backend.available(2)) return bitmapToPng(backend, backend.get(2));
+    if (pngFailure) throw pngFailure;
+    return null;
+  });
+}
+__name(getWindowsClipboardImage, "getWindowsClipboardImage");
+function bitmapToPng(backend, handle) {
+  if (!handle) throw new Error("GetClipboardData failed");
+  const { koffi } = backend;
+  const gdi = backend.load("gdi32.dll");
+  const bitmap = Buffer.alloc(koffi.sizeof("void *") === 8 ? 32 : 24);
+  const getObject = gdi.func("__stdcall", "GetObjectW", "int", [
+    "void *",
+    "int",
+    "void *"
+  ]);
+  if (getObject(handle, bitmap.length, bitmap) !== bitmap.length)
+    throw new Error("GetObjectW failed");
+  checkDimensions(bitmap.readInt32LE(4), bitmap.readInt32LE(8));
+  const gdiplus = backend.load("gdiplus.dll");
+  const ole = backend.load("ole32.dll");
+  const input = koffi.struct({
+    version: "uint32_t",
+    callback: "void *",
+    suppressThread: "int",
+    suppressCodecs: "int"
+  });
+  const startup = gdiplus.func("__stdcall", "GdiplusStartup", "int", [
+    "_Out_ uintptr_t *",
+    koffi.pointer(input),
+    "void *"
+  ]);
+  const shutdown = gdiplus.func("__stdcall", "GdiplusShutdown", "void", [
+    "uintptr_t"
+  ]);
+  const create = gdiplus.func(
+    "__stdcall",
+    "GdipCreateBitmapFromHBITMAP",
+    "int",
+    ["void *", "void *", "_Out_ void **"]
+  );
+  const dispose = gdiplus.func("__stdcall", "GdipDisposeImage", "int", [
+    "void *"
+  ]);
+  const streamCreate = ole.func(
+    "__stdcall",
+    "CreateStreamOnHGlobal",
+    "int32_t",
+    ["void *", "int", "_Out_ void **"]
+  );
+  const streamGlobal = ole.func(
+    "__stdcall",
+    "GetHGlobalFromStream",
+    "int32_t",
+    ["void *", "_Out_ void **"]
+  );
+  const save = gdiplus.func("__stdcall", "GdipSaveImageToStream", "int", [
+    "void *",
+    "void *",
+    "void *",
+    "void *"
+  ]);
+  const token = [0n];
+  const image = [null];
+  const stream = [null];
+  const global = [null];
+  const check = /* @__PURE__ */ __name((status, operation) => {
+    if (status !== 0) throw new Error(`${operation} failed (${status})`);
+  }, "check");
+  check(
+    startup(
+      token,
+      { version: 1, callback: null, suppressThread: 0, suppressCodecs: 0 },
+      null
+    ),
+    "GdiplusStartup"
+  );
+  try {
+    check(create(handle, null, image), "GdipCreateBitmapFromHBITMAP");
+    if (!image[0])
+      throw new Error("GdipCreateBitmapFromHBITMAP returned no image");
+    try {
+      check(streamCreate(null, 1, stream), "CreateStreamOnHGlobal");
+      if (!stream[0])
+        throw new Error("CreateStreamOnHGlobal returned no stream");
+      try {
+        const encoder = Buffer.from("06f47c55041ad3119a730000f81ef32e", "hex");
+        check(
+          save(image[0], stream[0], encoder, null),
+          "GdipSaveImageToStream"
+        );
+        check(streamGlobal(stream[0], global), "GetHGlobalFromStream");
+        return trimPng(copyGlobal(backend, global[0]));
+      } finally {
+        const vtable = koffi.decode(stream[0], "void *");
+        const release = koffi.decode(
+          vtable,
+          2 * koffi.sizeof("void *"),
+          "void *"
+        );
+        koffi.call(
+          release,
+          koffi.proto("__stdcall", "uint32_t", ["void *"]),
+          stream[0]
+        );
+      }
+    } finally {
+      dispose(image[0]);
+    }
+  } finally {
+    shutdown(token[0]);
+  }
+}
+__name(bitmapToPng, "bitmapToPng");
+
+export {
+  hasWindowsClipboardImage,
+  getWindowsClipboardText,
+  getWindowsClipboardImage
+};

package/chunks/{chunk-ITCYJNMA.js → chunk-4P64F4DP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   sandboxAsset
-} from "./chunk-KICY6OQ7.js";
+} from "./chunk-PHCY2DQ2.js";
 import {
   Storage
 } from "./chunk-S3HSUBBN.js";

package/chunks/{chunk-XHXYPNK5.js → chunk-5MP3GGWM.js}

@@ -6,8 +6,8 @@ import {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "6e4def3";
-var CLI_VERSION = "0.20.0";
+var GIT_COMMIT_INFO = "6390d4b";
+var CLI_VERSION = "0.20.1";
 
 export {
   GIT_COMMIT_INFO,

package/chunks/{chunk-XY2UI5DC.js → chunk-62UWQRWK.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   GIT_COMMIT_INFO
-} from "./chunk-XHXYPNK5.js";
+} from "./chunk-5MP3GGWM.js";
 import {
   getCliVersion
-} from "./chunk-FC4ZD65F.js";
+} from "./chunk-JIECZNY6.js";
 import {
   IdeClient
-} from "./chunk-VGPRZT2M.js";
+} from "./chunk-T4WPMWU4.js";
 import {
   formatMemoryUsage
 } from "./chunk-M7AWQAB7.js";

package/chunks/{chunk-P37WPAXB.js → chunk-6UDLEDID.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-6BOPO2CB.js";
+} from "./chunk-QFGPKAOX.js";
 import {
   init_esbuild_shims
 } from "./chunk-S2467S6L.js";

package/chunks/{chunk-JO2NW4DA.js → chunk-7ADYEHKM.js}

@@ -7,7 +7,7 @@ import {
 import {
   SERVE_CONTROL_EXT_METHODS,
   STATUS_SCHEMA_VERSION
-} from "./chunk-T65U3AIV.js";
+} from "./chunk-SU6K5JRJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-S2467S6L.js";

package/chunks/{chunk-TFAHTLY5.js → chunk-7CDZR7TE.js}

@@ -406,22 +406,22 @@ async function createContentGenerator(generatorConfig, config) {
   try {
     if (authType === "openai" /* USE_OPENAI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-C3PXKTPV.js");
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-XNEEZYGM.js");
         return createOpenAIContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "openai-responses" /* USE_OPENAI_RESPONSES */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIResponsesContentGenerator } = await import("./openaiResponsesContentGenerator-SLIXPGB7.js");
+        const { createOpenAIResponsesContentGenerator } = await import("./openaiResponsesContentGenerator-PAWM7H5R.js");
         return createOpenAIResponsesContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-XZTRPOXZ.js");
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-C4H5D7AR.js");
         return createAnthropicContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createLlmContentGenerator } = await import("./llm-content-generator-KM3RKFZX.js");
+        const { createLlmContentGenerator } = await import("./llm-content-generator-SFPAYYOJ.js");
         return createLlmContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else {
@@ -436,7 +436,7 @@ async function createContentGenerator(generatorConfig, config) {
     try {
       const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
         loadBaseGenerator(),
-        import("./loggingContentGenerator-RPWVHJXT.js")
+        import("./loggingContentGenerator-5MDGVYRW.js")
       ]);
       return new LoggingContentGenerator(
         baseGenerator,

package/chunks/{chunk-Y4ENGAFT.js → chunk-7HCWHQSP.js}

@@ -12,7 +12,7 @@ import {
 import {
   captureRuntimeFileVersion,
   writeRuntimeFile
-} from "./chunk-2D2DZP65.js";
+} from "./chunk-ASWPB74Q.js";
 import {
   checkTeamMemorySecrets
 } from "./chunk-ZMZRVR62.js";
@@ -24,20 +24,20 @@ import {
   detectLineEnding,
   getDiffStat,
   needsUtf8Bom
-} from "./chunk-VGPRZT2M.js";
+} from "./chunk-T4WPMWU4.js";
 import {
   FileOperationEvent,
   getLanguageFromFilePath,
   logFileOperation
-} from "./chunk-KBDFOYPK.js";
-import {
-  fileExists,
-  getSpecificMimeType
-} from "./chunk-ROO6F2BT.js";
+} from "./chunk-ASQLIG2L.js";
 import {
   isAnyAutoMemPath,
   isTeamAutoMemPath
 } from "./chunk-5P5ZJMW2.js";
+import {
+  fileExists,
+  getSpecificMimeType
+} from "./chunk-ROO6F2BT.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,

package/chunks/{chunk-DCSRFE4W.js → chunk-7QFTUN62.js}

@@ -585,7 +585,7 @@ var WorkspaceRegistrationStore = class {
     return removed;
   }
   async update(mutate) {
-    const { atomicWriteFile } = await import("./deferred-core-runtime-HPHPB3AS.js");
+    const { atomicWriteFile } = await import("./deferred-core-runtime-CJQCZJPG.js");
     return withInProcessLock(this.filePath, async () => {
       const lock = await acquireFileLock(this.filePath);
       let committed = false;

package/chunks/{chunk-Z3JO7QH2.js → chunk-A55LB5TM.js}

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

package/chunks/{chunk-N362SBSD.js → chunk-AIU3JWUX.js}

@@ -3,13 +3,13 @@
 import {
   buildModelIdContext,
   resolveModelId
-} from "./chunk-TR2AGNCI.js";
+} from "./chunk-SKPIIDV3.js";
 import {
   DASHSCOPE_REGIONAL_HOSTS
-} from "./chunk-PPR66GNG.js";
+} from "./chunk-OMMOMHTD.js";
 import {
   buildOutboundFetch
-} from "./chunk-YAUMOXEH.js";
+} from "./chunk-VYUHXV5Q.js";
 import {
   delay
 } from "./chunk-TC2TJAOF.js";
@@ -27,17 +27,17 @@ import {
   findProviderByCredentials,
   resolveModelApiKey,
   resolveRequestTimeout
-} from "./chunk-I3YBDADP.js";
-import {
-  OpenAI
-} from "./chunk-KMWAEX43.js";
+} from "./chunk-D7DZAA5W.js";
 import {
   getDefaultApiKeyEnvVar
-} from "./chunk-TFAHTLY5.js";
+} from "./chunk-7CDZR7TE.js";
 import {
   buildRuntimeFetchOptions,
   preloadRuntimeFetchModule
 } from "./chunk-HDGYCLNB.js";
+import {
+  OpenAI
+} from "./chunk-KMWAEX43.js";
 import {
   createDebugLogger
 } from "./chunk-UK2KIU2V.js";