@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-nightly.20260909.2e212144d3

package/chunks/chunk-NFXXBWSE.js

@@ -0,0 +1,463 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isSameProcess,
+  readLocalBootId,
+  readPidNamespaceId,
+  readProcStartToken
+} from "./chunk-CH2YDT6X.js";
+import {
+  require_proper_lockfile
+} from "./chunk-MLXTMF7H.js";
+import {
+  Storage
+} from "./chunk-ZAFYHRVY.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/channel/pidfile.ts
+init_esbuild_shims();
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  openSync,
+  closeSync,
+  constants,
+  ftruncateSync,
+  writeSync
+} from "node:fs";
+import * as path2 from "node:path";
+
+// packages/cli/src/commands/channel/pidfile-lock.ts
+init_esbuild_shims();
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import fs from "node:fs";
+import path from "node:path";
+var RETRY_DELAYS_MS = [10, 20, 30, 40, 50];
+var STALE_LOCK_MS = 1e4;
+var sleepState = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(ms) {
+  Atomics.wait(sleepState, 0, 0, ms);
+}
+__name(sleepSync, "sleepSync");
+function withChannelPidfileLock(filePath, operation) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  let release;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      release = import_proper_lockfile.default.lockSync(filePath, {
+        realpath: false,
+        stale: STALE_LOCK_MS
+      });
+      break;
+    } catch (error) {
+      const lockError = error;
+      if (lockError.code !== "ELOCKED") {
+        throw error;
+      }
+      if (attempt >= RETRY_DELAYS_MS.length) {
+        throw Object.assign(
+          new Error(
+            `Channel pidfile lock ${filePath}.lock is held; an abandoned lock recovers automatically after ${STALE_LOCK_MS / 1e3} seconds.`,
+            { cause: error }
+          ),
+          { code: "ELOCKED" }
+        );
+      }
+      sleepSync(RETRY_DELAYS_MS[attempt]);
+    }
+  }
+  try {
+    return operation();
+  } finally {
+    release();
+  }
+}
+__name(withChannelPidfileLock, "withChannelPidfileLock");
+
+// packages/cli/src/commands/channel/pidfile.ts
+function pidFilePath() {
+  return path2.join(Storage.getGlobalQwenDir(), "channels", "service.pid");
+}
+__name(pidFilePath, "pidFilePath");
+function isValidPid(pid) {
+  return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0;
+}
+__name(isValidPid, "isValidPid");
+function parseServiceInfo(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  const info = value;
+  const owner = info.owner ?? "channel";
+  if (owner !== "channel" && owner !== "serve") return null;
+  if (!isValidPid(info.pid) || typeof info.startedAt !== "string" || Number.isNaN(Date.parse(info.startedAt)) || !Array.isArray(info.channels) || !info.channels.every((channel) => typeof channel === "string")) {
+    return null;
+  }
+  if (info.servePid !== void 0 && !isValidPid(info.servePid)) return null;
+  if (info.workerPid !== void 0 && !isValidPid(info.workerPid)) return null;
+  if (info.procStart !== void 0 && info.procStart !== null && typeof info.procStart !== "string") {
+    return null;
+  }
+  if (info.pidNs !== void 0 && info.pidNs !== null && typeof info.pidNs !== "number") {
+    return null;
+  }
+  const workers = parseServiceInfoWorkers(info.workers);
+  if (workers === null) return null;
+  return {
+    owner,
+    pid: info.pid,
+    ...info.procStart !== void 0 ? { procStart: info.procStart } : {},
+    ...info.pidNs !== void 0 ? { pidNs: info.pidNs } : {},
+    startedAt: info.startedAt,
+    channels: info.channels,
+    ...info.servePid !== void 0 ? { servePid: info.servePid } : {},
+    ...info.workerPid !== void 0 ? { workerPid: info.workerPid } : {},
+    ...workers !== void 0 ? { workers } : {}
+  };
+}
+__name(parseServiceInfo, "parseServiceInfo");
+function parseServiceInfoWorkers(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) return null;
+  const workers = [];
+  for (const raw of value) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      return null;
+    }
+    const worker = raw;
+    if (!Array.isArray(worker.channels) || !worker.channels.every((channel) => typeof channel === "string")) {
+      return null;
+    }
+    if (worker.workspaceId !== void 0 && typeof worker.workspaceId !== "string") {
+      return null;
+    }
+    if (worker.workspaceCwd !== void 0 && typeof worker.workspaceCwd !== "string") {
+      return null;
+    }
+    if (worker.workerPid !== void 0 && !isValidPid(worker.workerPid)) {
+      return null;
+    }
+    workers.push({
+      channels: worker.channels,
+      ...worker.workspaceId !== void 0 ? { workspaceId: worker.workspaceId } : {},
+      ...worker.workspaceCwd !== void 0 ? { workspaceCwd: worker.workspaceCwd } : {},
+      ...worker.workerPid !== void 0 ? { workerPid: worker.workerPid } : {}
+    });
+  }
+  return workers;
+}
+__name(parseServiceInfoWorkers, "parseServiceInfoWorkers");
+function unlinkPidFile(filePath) {
+  try {
+    unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(unlinkPidFile, "unlinkPidFile");
+function bootIdOf(procStart) {
+  if (procStart == null) return null;
+  const separator = procStart.indexOf(":");
+  return separator === -1 ? null : procStart.slice(0, separator);
+}
+__name(bootIdOf, "bootIdOf");
+function isLocalIdentity(info) {
+  if (info.pidNs !== void 0 && info.pidNs !== readPidNamespaceId()) {
+    return false;
+  }
+  const recordBootId = bootIdOf(info.procStart);
+  return recordBootId === null || recordBootId === readLocalBootId();
+}
+__name(isLocalIdentity, "isLocalIdentity");
+function isOwnServeReservation(info, servePid) {
+  return info !== null && info.owner === "serve" && info.pid === servePid && info.servePid === servePid && isLocalIdentity(info);
+}
+__name(isOwnServeReservation, "isOwnServeReservation");
+function withPidFileLock(operation) {
+  const filePath = pidFilePath();
+  return withChannelPidfileLock(filePath, () => operation(filePath));
+}
+__name(withPidFileLock, "withPidFileLock");
+function readServiceInfo() {
+  const filePath = pidFilePath();
+  if (!existsSync(filePath)) return null;
+  try {
+    return withChannelPidfileLock(
+      filePath,
+      () => readServiceInfoRecord(filePath, true)
+    );
+  } catch {
+    return readServiceInfoRecord(filePath, false);
+  }
+}
+__name(readServiceInfo, "readServiceInfo");
+function readServiceInfoRecord(filePath, sweep) {
+  if (!existsSync(filePath)) return null;
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    if (sweep) unlinkPidFile(filePath);
+    return null;
+  }
+  const info = parseServiceInfo(parsed);
+  if (!info) {
+    if (sweep) unlinkPidFile(filePath);
+    return null;
+  }
+  if (!isLocalIdentity(info)) {
+    return null;
+  }
+  if (!isSameProcess(info.pid, info.procStart)) {
+    if (sweep) unlinkPidFile(filePath);
+    return null;
+  }
+  return info;
+}
+__name(readServiceInfoRecord, "readServiceInfoRecord");
+function writeInfo(info, flag = "w") {
+  const filePath = pidFilePath();
+  const dir = path2.dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, JSON.stringify(info, null, 2), {
+    encoding: "utf-8",
+    flag
+  });
+}
+__name(writeInfo, "writeInfo");
+function fileExistsError(message) {
+  const err = new Error(message);
+  err.code = "EEXIST";
+  return err;
+}
+__name(fileExistsError, "fileExistsError");
+function writeInfoExclusive(info) {
+  const filePath = pidFilePath();
+  try {
+    writeInfo(info, "wx");
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    let existing = null;
+    try {
+      existing = parseServiceInfo(JSON.parse(readFileSync(filePath, "utf-8")));
+    } catch {
+      throw err;
+    }
+    if (existing && !isLocalIdentity(existing)) {
+      const conflict = new Error(
+        `Channel service pidfile ${filePath} holds a record this machine cannot verify, written before a reboot or by another machine or PID namespace sharing this home. Confirm no channel service is running, then delete that file to start again.`
+      );
+      conflict.code = "channel_service_conflict";
+      throw conflict;
+    }
+    if (existing && isSameProcess(existing.pid, existing.procStart)) {
+      throw err;
+    }
+    unlinkPidFile(filePath);
+    writeInfo(info, "wx");
+  }
+}
+__name(writeInfoExclusive, "writeInfoExclusive");
+function readPidfileProcessToken(pid) {
+  let procStart = readProcStartToken(pid);
+  if (process.platform !== "linux" || procStart !== null) return procStart;
+  procStart = readProcStartToken(pid);
+  if (procStart !== null) return procStart;
+  throw new Error(
+    `Unable to read the process start token for PID ${pid}; refusing to write an impersonable Channel pidfile.`
+  );
+}
+__name(readPidfileProcessToken, "readPidfileProcessToken");
+function readPidfileNamespaceId() {
+  let pidNs = readPidNamespaceId();
+  if (process.platform !== "linux" || pidNs !== null) return pidNs;
+  pidNs = readPidNamespaceId();
+  if (pidNs !== null) return pidNs;
+  throw new Error(
+    "Unable to read the PID namespace id; refusing to write an unreclaimable Channel pidfile."
+  );
+}
+__name(readPidfileNamespaceId, "readPidfileNamespaceId");
+function writeServiceInfo(channels) {
+  const info = {
+    owner: "channel",
+    pid: process.pid,
+    procStart: readPidfileProcessToken(process.pid),
+    pidNs: readPidfileNamespaceId(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    channels
+  };
+  withPidFileLock(() => writeInfoExclusive(info));
+}
+__name(writeServiceInfo, "writeServiceInfo");
+function writeServeServiceInfo({
+  channels,
+  servePid = process.pid,
+  workerPid,
+  workers
+}) {
+  const buildInfo = /* @__PURE__ */ __name((startedAt, procStart) => ({
+    owner: "serve",
+    pid: servePid,
+    procStart,
+    pidNs: readPidfileNamespaceId(),
+    startedAt,
+    channels,
+    servePid,
+    ...workerPid !== void 0 ? { workerPid } : {},
+    ...workers !== void 0 ? { workers } : {}
+  }), "buildInfo");
+  withPidFileLock((filePath) => {
+    let fd;
+    try {
+      fd = openSync(filePath, constants.O_RDWR | constants.O_NOFOLLOW);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        writeInfo(
+          buildInfo(
+            (/* @__PURE__ */ new Date()).toISOString(),
+            readPidfileProcessToken(servePid)
+          ),
+          "wx"
+        );
+        return;
+      }
+      throw err;
+    }
+    try {
+      let existing = null;
+      try {
+        existing = parseServiceInfo(JSON.parse(readFileSync(fd, "utf-8")));
+      } catch {
+      }
+      if (!isOwnServeReservation(existing, servePid)) {
+        throw fileExistsError(
+          "Channel service pidfile is owned by another process."
+        );
+      }
+      const info = buildInfo(
+        existing.startedAt,
+        existing.procStart ?? readPidfileProcessToken(servePid)
+      );
+      ftruncateSync(fd, 0);
+      writeSync(fd, JSON.stringify(info, null, 2), 0, "utf-8");
+    } finally {
+      closeSync(fd);
+    }
+  });
+}
+__name(writeServeServiceInfo, "writeServeServiceInfo");
+function reserveServeServiceInfo({
+  channels,
+  servePid = process.pid
+}) {
+  const info = {
+    owner: "serve",
+    pid: servePid,
+    procStart: readPidfileProcessToken(servePid),
+    pidNs: readPidfileNamespaceId(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    channels,
+    servePid
+  };
+  withPidFileLock(() => writeInfoExclusive(info));
+}
+__name(reserveServeServiceInfo, "reserveServeServiceInfo");
+function removeServiceInfo(expected) {
+  try {
+    withPidFileLock((filePath) => {
+      if (!expected) {
+        if (existsSync(filePath)) unlinkPidFile(filePath);
+        return;
+      }
+      try {
+        const current = parseServiceInfo(
+          JSON.parse(readFileSync(filePath, "utf-8"))
+        );
+        if (current?.owner === expected.owner && current.pid === expected.pid && current.procStart === expected.procStart && current.startedAt === expected.startedAt) {
+          unlinkPidFile(filePath);
+        }
+      } catch {
+      }
+    });
+  } catch {
+  }
+}
+__name(removeServiceInfo, "removeServiceInfo");
+function removeServeServiceInfo(servePid = process.pid) {
+  try {
+    return withPidFileLock((filePath) => {
+      if (!existsSync(filePath)) return false;
+      let parsed;
+      try {
+        parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+      } catch {
+        return false;
+      }
+      if (!isOwnServeReservation(parseServiceInfo(parsed), servePid)) {
+        return false;
+      }
+      return unlinkPidFile(filePath);
+    });
+  } catch {
+    return false;
+  }
+}
+__name(removeServeServiceInfo, "removeServeServiceInfo");
+function signalService(pid, signal = "SIGTERM", procStart) {
+  if (!isValidPid(pid)) {
+    return "refused";
+  }
+  if (procStart != null) {
+    const current = readProcStartToken(pid) ?? readProcStartToken(pid);
+    if (current !== procStart) return "refused";
+  }
+  try {
+    process.kill(pid, signal);
+    return "sent";
+  } catch (err) {
+    return err.code === "EPERM" ? "not-permitted" : "refused";
+  }
+}
+__name(signalService, "signalService");
+async function waitForExit(pid, timeoutMs = 5e3, pollMs = 200, procStart) {
+  const isOriginalProcessAlive = /* @__PURE__ */ __name(() => isSameProcess(pid, procStart), "isOriginalProcessAlive");
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!isOriginalProcessAlive()) return true;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return !isOriginalProcessAlive();
+}
+__name(waitForExit, "waitForExit");
+
+export {
+  pidFilePath,
+  readServiceInfo,
+  writeServiceInfo,
+  writeServeServiceInfo,
+  reserveServeServiceInfo,
+  removeServiceInfo,
+  removeServeServiceInfo,
+  signalService,
+  waitForExit
+};

package/chunks/chunk-NOO4QFXM.js

@@ -0,0 +1,171 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  createDebugLogger
+} from "./chunk-ZAFYHRVY.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/outbound-session-id.ts
+init_esbuild_shims();
+
+// 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|QWEN_CODE_SESSION_ID)(?!\w)|\$\{(?:session_id|QWEN_CODE_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");
+
+// packages/core/src/core/outbound-session-id.ts
+var debugLogger2 = createDebugLogger("OUTBOUND_CORRELATION");
+var SESSION_ID_HEADER = "session_id";
+var SESSION_ID_HEADER_HOSTS = [
+  "routify.alibaba-inc.com",
+  "routify-online.alibaba-inc.com",
+  "routify-pub.alibaba-inc.com"
+];
+function requestUrl(input) {
+  try {
+    if (typeof input === "string") return new URL(input);
+    if (input instanceof URL) return input;
+    return new URL(input.url);
+  } catch {
+    return void 0;
+  }
+}
+__name(requestUrl, "requestUrl");
+function buildSessionIdHeaders(config, destination) {
+  try {
+    const url = requestUrl(destination);
+    if (url?.protocol !== "https:" || !SESSION_ID_HEADER_HOSTS.includes(url.hostname.toLowerCase())) {
+      return {};
+    }
+    const sessionId = config.getSessionId();
+    return sessionId ? { [SESSION_ID_HEADER]: sessionId } : {};
+  } catch (error) {
+    debugLogger2.warn(
+      `Unable to add ${SESSION_ID_HEADER} to outbound request: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {};
+  }
+}
+__name(buildSessionIdHeaders, "buildSessionIdHeaders");
+function wrapFetchWithSessionId(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) => {
+    const sessionHeaders = buildSessionIdHeaders(config, input);
+    const sessionId = sessionHeaders[SESSION_ID_HEADER];
+    if (!sessionId && !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));
+    if (expandsHeaders) applyDynamicHeaderValues(headers, config);
+    if (sessionId) headers.set(SESSION_ID_HEADER, sessionId);
+    return fetchLike(input, { ...init, headers });
+  }, "wrapped");
+  return wrapped;
+}
+__name(wrapFetchWithSessionId, "wrapFetchWithSessionId");
+function buildSessionAwareFetch(runtimeFetch, config, customHeaders) {
+  const baseFetch = runtimeFetch ?? globalThis.fetch;
+  return wrapFetchWithSessionId(baseFetch, config, customHeaders);
+}
+__name(buildSessionAwareFetch, "buildSessionAwareFetch");
+
+export {
+  warnIfDynamicHeadersDisabled,
+  hasDynamicPlaceholder,
+  expandDynamicHeaders,
+  buildSessionIdHeaders,
+  buildSessionAwareFetch
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-PQSCGZT2.js → chunk-NPKCVSXX.js}

@@ -244,6 +244,19 @@ function convertLlmToolParametersToOpenAI(parameters) {
 }
 __name(convertLlmToolParametersToOpenAI, "convertLlmToolParametersToOpenAI");
 var grammarSchemaValidationCache = /* @__PURE__ */ new WeakMap();
+var PARAMETERLESS_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "$comment",
+  "$schema",
+  "additionalProperties",
+  "deprecated",
+  "description",
+  "examples",
+  "properties",
+  "readOnly",
+  "title",
+  "type",
+  "writeOnly"
+]);
 function isStrictlyValidSchema(schema) {
   const cached = grammarSchemaValidationCache.get(schema);
   if (cached !== void 0) {
@@ -278,13 +291,24 @@ async function convertLlmToolsToOpenAI(llmTools, schemaCompliance = "auto") {
             );
           }
           if (parameters) {
-            const sourceSchema = func.parametersJsonSchema;
-            const canValidateLocally = typeof sourceSchema === "object" && sourceSchema !== null && !Array.isArray(sourceSchema) && !("$id" in sourceSchema) && isStrictlyValidSchema(sourceSchema);
+            const sourceSchema = typeof func.parametersJsonSchema === "object" && func.parametersJsonSchema !== null && !Array.isArray(func.parametersJsonSchema) ? func.parametersJsonSchema : void 0;
+            const canValidateLocally = sourceSchema !== void 0 && !("$id" in sourceSchema) && isStrictlyValidSchema(sourceSchema);
+            const sourceProperties = sourceSchema?.["properties"];
+            const sourceAdditionalProperties = sourceSchema?.["additionalProperties"];
+            const hasEmptyProperties = typeof sourceProperties === "object" && sourceProperties !== null && !Array.isArray(sourceProperties) && Object.keys(sourceProperties).length === 0;
+            const declaresEmptyArgumentList = sourceSchema !== void 0 && (hasEmptyProperties && (sourceAdditionalProperties === false || sourceAdditionalProperties === void 0) || sourceProperties === void 0 && sourceAdditionalProperties === false) && Object.keys(sourceSchema).every(
+              (key) => PARAMETERLESS_SCHEMA_KEYS.has(key)
+            );
             parameters = convertSchema(parameters, schemaCompliance);
             parameters = relaxSchemaForFunctionCalling(
               parameters,
               canValidateLocally
             );
+            if (canValidateLocally && declaresEmptyArgumentList && parameters["type"] === "object" && Object.keys(parameters).every(
+              (key) => PARAMETERLESS_SCHEMA_KEYS.has(key)
+            )) {
+              parameters = void 0;
+            }
           }
           openAITools.push({
             type: "function",