@qwen-code/qwen-code 0.16.1 → 0.16.2

package/chunks/{chunk-JCR2WRXZ.js → chunk-4YNZFYJY.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-OFEVLU4C.js";
 import {
   isAutoMemPath
-} from "./chunk-PR4T27R7.js";
+} from "./chunk-NQ3E7YLD.js";
 import {
   DEFAULT_OPENAI_BASE_URL,
   convertSchema,
@@ -17,23 +17,23 @@ import {
   runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-MAY32HXD.js";
+} from "./chunk-6NUSWV4M.js";
 import {
   InstallationManager
-} from "./chunk-D5NTAHYL.js";
+} from "./chunk-ODPVJ6JJ.js";
 import {
   FinishReason,
   GenerateContentResponse
 } from "./chunk-T4VD6OJ4.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-YJLGXDQJ.js";
+} from "./chunk-FO7BIVSR.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-PVVL5Q3W.js";
+} from "./chunk-YMDXEEOW.js";
 import {
   FatalConfigError,
   Storage,
@@ -49,7 +49,7 @@ import {
   setSessionContext,
   shortenPath,
   unescapePath
-} from "./chunk-XP27SJMH.js";
+} from "./chunk-ACBGEKB7.js";
 import {
   require_dist
 } from "./chunk-ZERZSAZL.js";
@@ -62445,6 +62445,506 @@ var require_src30 = __commonJS({
   }
 });
 
+// node_modules/@opentelemetry/instrumentation-undici/build/src/version.js
+var require_version10 = __commonJS({
+  "node_modules/@opentelemetry/instrumentation-undici/build/src/version.js"(exports2) {
+    "use strict";
+    init_esbuild_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PACKAGE_NAME = exports2.PACKAGE_VERSION = void 0;
+    exports2.PACKAGE_VERSION = "0.14.0";
+    exports2.PACKAGE_NAME = "@opentelemetry/instrumentation-undici";
+  }
+});
+
+// node_modules/@opentelemetry/instrumentation-undici/build/src/enums/SemanticAttributes.js
+var require_SemanticAttributes = __commonJS({
+  "node_modules/@opentelemetry/instrumentation-undici/build/src/enums/SemanticAttributes.js"(exports2) {
+    "use strict";
+    init_esbuild_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SemanticAttributes = void 0;
+    exports2.SemanticAttributes = {
+      /**
+       * State of the HTTP connection in the HTTP connection pool.
+       */
+      HTTP_CONNECTION_STATE: "http.connection.state",
+      /**
+        * Describes a class of error the operation ended with.
+        *
+        * Note: The `error.type` SHOULD be predictable and SHOULD have low cardinality.
+      Instrumentations SHOULD document the list of errors they report.
+      
+      The cardinality of `error.type` within one instrumentation library SHOULD be low.
+      Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
+      should be prepared for `error.type` to have high cardinality at query time when no
+      additional filters are applied.
+      
+      If the operation has completed successfully, instrumentations SHOULD NOT set `error.type`.
+      
+      If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes),
+      it's RECOMMENDED to:
+      
+      * Use a domain-specific attribute
+      * Set `error.type` to capture all errors, regardless of whether they are defined within the domain-specific set or not.
+        */
+      ERROR_TYPE: "error.type",
+      /**
+       * The size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length) header. For requests using transport encoding, this should be the compressed size.
+       */
+      HTTP_REQUEST_BODY_SIZE: "http.request.body.size",
+      /**
+        * HTTP request method.
+        *
+        * Note: HTTP request method value SHOULD be "known" to the instrumentation.
+      By default, this convention defines "known" methods as the ones listed in [RFC9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-methods)
+      and the PATCH method defined in [RFC5789](https://www.rfc-editor.org/rfc/rfc5789.html).
+      
+      If the HTTP request method is not known to instrumentation, it MUST set the `http.request.method` attribute to `_OTHER`.
+      
+      If the HTTP instrumentation could end up converting valid HTTP request methods to `_OTHER`, then it MUST provide a way to override
+      the list of known HTTP methods. If this override is done via environment variable, then the environment variable MUST be named
+      OTEL_INSTRUMENTATION_HTTP_KNOWN_METHODS and support a comma-separated list of case-sensitive known HTTP methods
+      (this list MUST be a full override of the default known method, it is not a list of known methods in addition to the defaults).
+      
+      HTTP method names are case-sensitive and `http.request.method` attribute value MUST match a known HTTP method name exactly.
+      Instrumentations for specific web frameworks that consider HTTP methods to be case insensitive, SHOULD populate a canonical equivalent.
+      Tracing instrumentations that do so, MUST also set `http.request.method_original` to the original value.
+        */
+      HTTP_REQUEST_METHOD: "http.request.method",
+      /**
+       * Original HTTP method sent by the client in the request line.
+       */
+      HTTP_REQUEST_METHOD_ORIGINAL: "http.request.method_original",
+      /**
+       * The ordinal number of request resending attempt (for any reason, including redirects).
+       *
+       * Note: The resend count SHOULD be updated each time an HTTP request gets resent by the client, regardless of what was the cause of the resending (e.g. redirection, authorization failure, 503 Server Unavailable, network issues, or any other).
+       */
+      HTTP_REQUEST_RESEND_COUNT: "http.request.resend_count",
+      /**
+       * The size of the response payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length) header. For requests using transport encoding, this should be the compressed size.
+       */
+      HTTP_RESPONSE_BODY_SIZE: "http.response.body.size",
+      /**
+       * [HTTP response status code](https://tools.ietf.org/html/rfc7231#section-6).
+       */
+      HTTP_RESPONSE_STATUS_CODE: "http.response.status_code",
+      /**
+        * The matched route, that is, the path template in the format used by the respective server framework.
+        *
+        * Note: MUST NOT be populated when this is not supported by the HTTP server framework as the route attribute should have low-cardinality and the URI path can NOT substitute it.
+      SHOULD include the [application root](/docs/http/http-spans.md#http-server-definitions) if there is one.
+        */
+      HTTP_ROUTE: "http.route",
+      /**
+       * Peer address of the network connection - IP address or Unix domain socket name.
+       */
+      NETWORK_PEER_ADDRESS: "network.peer.address",
+      /**
+       * Peer port number of the network connection.
+       */
+      NETWORK_PEER_PORT: "network.peer.port",
+      /**
+       * [OSI application layer](https://osi-model.com/application-layer/) or non-OSI equivalent.
+       *
+       * Note: The value SHOULD be normalized to lowercase.
+       */
+      NETWORK_PROTOCOL_NAME: "network.protocol.name",
+      /**
+       * Version of the protocol specified in `network.protocol.name`.
+       *
+       * Note: `network.protocol.version` refers to the version of the protocol used and might be different from the protocol client's version. If the HTTP client has a version of `0.27.2`, but sends HTTP version `1.1`, this attribute should be set to `1.1`.
+       */
+      NETWORK_PROTOCOL_VERSION: "network.protocol.version",
+      /**
+       * Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name.
+       *
+       * Note: When observed from the client side, and when communicating through an intermediary, `server.address` SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
+       */
+      SERVER_ADDRESS: "server.address",
+      /**
+       * Server port number.
+       *
+       * Note: When observed from the client side, and when communicating through an intermediary, `server.port` SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
+       */
+      SERVER_PORT: "server.port",
+      /**
+        * Absolute URL describing a network resource according to [RFC3986](https://www.rfc-editor.org/rfc/rfc3986).
+        *
+        * Note: For network calls, URL usually has `scheme://host[:port][path][?query][#fragment]` format, where the fragment is not transmitted over HTTP, but if it is known, it SHOULD be included nevertheless.
+      `url.full` MUST NOT contain credentials passed via URL in form of `https://username:password@www.example.com/`. In such case username and password SHOULD be redacted and attribute's value SHOULD be `https://REDACTED:REDACTED@www.example.com/`.
+      `url.full` SHOULD capture the absolute URL when it is available (or can be reconstructed) and SHOULD NOT be validated or modified except for sanitizing purposes.
+        */
+      URL_FULL: "url.full",
+      /**
+       * The [URI path](https://www.rfc-editor.org/rfc/rfc3986#section-3.3) component.
+       */
+      URL_PATH: "url.path",
+      /**
+       * The [URI query](https://www.rfc-editor.org/rfc/rfc3986#section-3.4) component.
+       *
+       * Note: Sensitive content provided in query string SHOULD be scrubbed when instrumentations can identify it.
+       */
+      URL_QUERY: "url.query",
+      /**
+       * The [URI scheme](https://www.rfc-editor.org/rfc/rfc3986#section-3.1) component identifying the used protocol.
+       */
+      URL_SCHEME: "url.scheme",
+      /**
+       * Value of the [HTTP User-Agent](https://www.rfc-editor.org/rfc/rfc9110.html#field.user-agent) header sent by the client.
+       */
+      USER_AGENT_ORIGINAL: "user_agent.original"
+    };
+  }
+});
+
+// node_modules/@opentelemetry/instrumentation-undici/build/src/undici.js
+var require_undici = __commonJS({
+  "node_modules/@opentelemetry/instrumentation-undici/build/src/undici.js"(exports2) {
+    "use strict";
+    init_esbuild_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.UndiciInstrumentation = void 0;
+    var diagch = __require("diagnostics_channel");
+    var url_1 = __require("url");
+    var instrumentation_1 = require_src21();
+    var api_1 = (init_esm(), __toCommonJS(esm_exports));
+    var version_1 = require_version10();
+    var SemanticAttributes_1 = require_SemanticAttributes();
+    var core_1 = require_src3();
+    var UndiciInstrumentation2 = class extends instrumentation_1.InstrumentationBase {
+      static {
+        __name(this, "UndiciInstrumentation");
+      }
+      _recordFromReq = /* @__PURE__ */ new WeakMap();
+      constructor(config = {}) {
+        super(version_1.PACKAGE_NAME, version_1.PACKAGE_VERSION, config);
+      }
+      // No need to instrument files/modules
+      init() {
+        return void 0;
+      }
+      disable() {
+        super.disable();
+        this._channelSubs.forEach((sub) => sub.unsubscribe());
+        this._channelSubs.length = 0;
+      }
+      enable() {
+        super.enable();
+        this._channelSubs = this._channelSubs || [];
+        if (this._channelSubs.length > 0) {
+          return;
+        }
+        this.subscribeToChannel("undici:request:create", this.onRequestCreated.bind(this));
+        this.subscribeToChannel("undici:client:sendHeaders", this.onRequestHeaders.bind(this));
+        this.subscribeToChannel("undici:request:headers", this.onResponseHeaders.bind(this));
+        this.subscribeToChannel("undici:request:trailers", this.onDone.bind(this));
+        this.subscribeToChannel("undici:request:error", this.onError.bind(this));
+      }
+      _updateMetricInstruments() {
+        this._httpClientDurationHistogram = this.meter.createHistogram("http.client.request.duration", {
+          description: "Measures the duration of outbound HTTP requests.",
+          unit: "s",
+          valueType: api_1.ValueType.DOUBLE,
+          advice: {
+            explicitBucketBoundaries: [
+              5e-3,
+              0.01,
+              0.025,
+              0.05,
+              0.075,
+              0.1,
+              0.25,
+              0.5,
+              0.75,
+              1,
+              2.5,
+              5,
+              7.5,
+              10
+            ]
+          }
+        });
+      }
+      subscribeToChannel(diagnosticChannel, onMessage) {
+        const [major, minor] = process.version.replace("v", "").split(".").map((n) => Number(n));
+        const useNewSubscribe = major > 18 || major === 18 && minor >= 19;
+        let unsubscribe;
+        if (useNewSubscribe) {
+          diagch.subscribe?.(diagnosticChannel, onMessage);
+          unsubscribe = /* @__PURE__ */ __name(() => diagch.unsubscribe?.(diagnosticChannel, onMessage), "unsubscribe");
+        } else {
+          const channel = diagch.channel(diagnosticChannel);
+          channel.subscribe(onMessage);
+          unsubscribe = /* @__PURE__ */ __name(() => channel.unsubscribe(onMessage), "unsubscribe");
+        }
+        this._channelSubs.push({
+          name: diagnosticChannel,
+          unsubscribe
+        });
+      }
+      parseRequestHeaders(request4) {
+        const result = /* @__PURE__ */ new Map();
+        if (Array.isArray(request4.headers)) {
+          for (let i = 0; i < request4.headers.length; i += 2) {
+            const key = request4.headers[i];
+            const value = request4.headers[i + 1];
+            if (typeof key === "string") {
+              result.set(key.toLowerCase(), value);
+            }
+          }
+        } else if (typeof request4.headers === "string") {
+          const headers = request4.headers.split("\r\n");
+          for (const line of headers) {
+            if (!line) {
+              continue;
+            }
+            const colonIndex = line.indexOf(":");
+            if (colonIndex === -1) {
+              continue;
+            }
+            const key = line.substring(0, colonIndex).toLowerCase();
+            const value = line.substring(colonIndex + 1).trim();
+            const allValues = result.get(key);
+            if (allValues && Array.isArray(allValues)) {
+              allValues.push(value);
+            } else if (allValues) {
+              result.set(key, [allValues, value]);
+            } else {
+              result.set(key, value);
+            }
+          }
+        }
+        return result;
+      }
+      // This is the 1st message we receive for each request (fired after request creation). Here we will
+      // create the span and populate some atttributes, then link the span to the request for further
+      // span processing
+      onRequestCreated({ request: request4 }) {
+        const config = this.getConfig();
+        const enabled = config.enabled !== false;
+        const shouldIgnoreReq = (0, instrumentation_1.safeExecuteInTheMiddle)(() => !enabled || request4.method === "CONNECT" || config.ignoreRequestHook?.(request4), (e) => e && this._diag.error("caught ignoreRequestHook error: ", e), true);
+        if (shouldIgnoreReq) {
+          return;
+        }
+        const startTime = (0, core_1.hrTime)();
+        let requestUrl;
+        try {
+          requestUrl = new url_1.URL(request4.path, request4.origin);
+        } catch (err) {
+          this._diag.warn("could not determine url.full:", err);
+          return;
+        }
+        const urlScheme = requestUrl.protocol.replace(":", "");
+        const requestMethod = this.getRequestMethod(request4.method);
+        const attributes = {
+          [SemanticAttributes_1.SemanticAttributes.HTTP_REQUEST_METHOD]: requestMethod,
+          [SemanticAttributes_1.SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL]: request4.method,
+          [SemanticAttributes_1.SemanticAttributes.URL_FULL]: requestUrl.toString(),
+          [SemanticAttributes_1.SemanticAttributes.URL_PATH]: requestUrl.pathname,
+          [SemanticAttributes_1.SemanticAttributes.URL_QUERY]: requestUrl.search,
+          [SemanticAttributes_1.SemanticAttributes.URL_SCHEME]: urlScheme
+        };
+        const schemePorts = { https: "443", http: "80" };
+        const serverAddress = requestUrl.hostname;
+        const serverPort = requestUrl.port || schemePorts[urlScheme];
+        attributes[SemanticAttributes_1.SemanticAttributes.SERVER_ADDRESS] = serverAddress;
+        if (serverPort && !isNaN(Number(serverPort))) {
+          attributes[SemanticAttributes_1.SemanticAttributes.SERVER_PORT] = Number(serverPort);
+        }
+        const headersMap = this.parseRequestHeaders(request4);
+        const userAgentValues = headersMap.get("user-agent");
+        if (userAgentValues) {
+          const userAgent = Array.isArray(userAgentValues) ? userAgentValues[userAgentValues.length - 1] : userAgentValues;
+          attributes[SemanticAttributes_1.SemanticAttributes.USER_AGENT_ORIGINAL] = userAgent;
+        }
+        const hookAttributes = (0, instrumentation_1.safeExecuteInTheMiddle)(() => config.startSpanHook?.(request4), (e) => e && this._diag.error("caught startSpanHook error: ", e), true);
+        if (hookAttributes) {
+          Object.entries(hookAttributes).forEach(([key, val]) => {
+            attributes[key] = val;
+          });
+        }
+        const activeCtx = api_1.context.active();
+        const currentSpan = api_1.trace.getSpan(activeCtx);
+        let span;
+        if (config.requireParentforSpans && (!currentSpan || !api_1.trace.isSpanContextValid(currentSpan.spanContext()))) {
+          span = api_1.trace.wrapSpanContext(api_1.INVALID_SPAN_CONTEXT);
+        } else {
+          span = this.tracer.startSpan(requestMethod === "_OTHER" ? "HTTP" : requestMethod, {
+            kind: api_1.SpanKind.CLIENT,
+            attributes
+          }, activeCtx);
+        }
+        (0, instrumentation_1.safeExecuteInTheMiddle)(() => config.requestHook?.(span, request4), (e) => e && this._diag.error("caught requestHook error: ", e), true);
+        const requestContext = api_1.trace.setSpan(api_1.context.active(), span);
+        const addedHeaders = {};
+        api_1.propagation.inject(requestContext, addedHeaders);
+        const headerEntries = Object.entries(addedHeaders);
+        for (let i = 0; i < headerEntries.length; i++) {
+          const [k, v] = headerEntries[i];
+          if (typeof request4.addHeader === "function") {
+            request4.addHeader(k, v);
+          } else if (typeof request4.headers === "string") {
+            request4.headers += `${k}: ${v}\r
+`;
+          } else if (Array.isArray(request4.headers)) {
+            request4.headers.push(k, v);
+          }
+        }
+        this._recordFromReq.set(request4, { span, attributes, startTime });
+      }
+      // This is the 2nd message we receive for each request. It is fired when connection with
+      // the remote is established and about to send the first byte. Here we do have info about the
+      // remote address and port so we can populate some `network.*` attributes into the span
+      onRequestHeaders({ request: request4, socket }) {
+        const record = this._recordFromReq.get(request4);
+        if (!record) {
+          return;
+        }
+        const config = this.getConfig();
+        const { span } = record;
+        const { remoteAddress, remotePort } = socket;
+        const spanAttributes = {
+          [SemanticAttributes_1.SemanticAttributes.NETWORK_PEER_ADDRESS]: remoteAddress,
+          [SemanticAttributes_1.SemanticAttributes.NETWORK_PEER_PORT]: remotePort
+        };
+        if (config.headersToSpanAttributes?.requestHeaders) {
+          const headersToAttribs = new Set(config.headersToSpanAttributes.requestHeaders.map((n) => n.toLowerCase()));
+          const headersMap = this.parseRequestHeaders(request4);
+          for (const [name, value] of headersMap.entries()) {
+            if (headersToAttribs.has(name)) {
+              const attrValue = Array.isArray(value) ? value.join(", ") : value;
+              spanAttributes[`http.request.header.${name}`] = attrValue;
+            }
+          }
+        }
+        span.setAttributes(spanAttributes);
+      }
+      // This is the 3rd message we get for each request and it's fired when the server
+      // headers are received, body may not be accessible yet.
+      // From the response headers we can set the status and content length
+      onResponseHeaders({ request: request4, response }) {
+        const record = this._recordFromReq.get(request4);
+        if (!record) {
+          return;
+        }
+        const { span, attributes } = record;
+        const spanAttributes = {
+          [SemanticAttributes_1.SemanticAttributes.HTTP_RESPONSE_STATUS_CODE]: response.statusCode
+        };
+        const config = this.getConfig();
+        (0, instrumentation_1.safeExecuteInTheMiddle)(() => config.responseHook?.(span, { request: request4, response }), (e) => e && this._diag.error("caught responseHook error: ", e), true);
+        const headersToAttribs = /* @__PURE__ */ new Set();
+        if (config.headersToSpanAttributes?.responseHeaders) {
+          config.headersToSpanAttributes?.responseHeaders.forEach((name) => headersToAttribs.add(name.toLowerCase()));
+        }
+        for (let idx = 0; idx < response.headers.length; idx = idx + 2) {
+          const name = response.headers[idx].toString().toLowerCase();
+          const value = response.headers[idx + 1];
+          if (headersToAttribs.has(name)) {
+            spanAttributes[`http.response.header.${name}`] = value.toString();
+          }
+          if (name === "content-length") {
+            const contentLength = Number(value.toString());
+            if (!isNaN(contentLength)) {
+              spanAttributes["http.response.header.content-length"] = contentLength;
+            }
+          }
+        }
+        span.setAttributes(spanAttributes);
+        span.setStatus({
+          code: response.statusCode >= 400 ? api_1.SpanStatusCode.ERROR : api_1.SpanStatusCode.UNSET
+        });
+        record.attributes = Object.assign(attributes, spanAttributes);
+      }
+      // This is the last event we receive if the request went without any errors
+      onDone({ request: request4 }) {
+        const record = this._recordFromReq.get(request4);
+        if (!record) {
+          return;
+        }
+        const { span, attributes, startTime } = record;
+        span.end();
+        this._recordFromReq.delete(request4);
+        this.recordRequestDuration(attributes, startTime);
+      }
+      // This is the event we get when something is wrong in the request like
+      // - invalid options when calling `fetch` global API or any undici method for request
+      // - connectivity errors such as unreachable host
+      // - requests aborted through an `AbortController.signal`
+      // NOTE: server errors are considered valid responses and it's the lib consumer
+      // who should deal with that.
+      onError({ request: request4, error }) {
+        const record = this._recordFromReq.get(request4);
+        if (!record) {
+          return;
+        }
+        const { span, attributes, startTime } = record;
+        span.recordException(error);
+        span.setStatus({
+          code: api_1.SpanStatusCode.ERROR,
+          message: error.message
+        });
+        span.end();
+        this._recordFromReq.delete(request4);
+        attributes[SemanticAttributes_1.SemanticAttributes.ERROR_TYPE] = error.message;
+        this.recordRequestDuration(attributes, startTime);
+      }
+      recordRequestDuration(attributes, startTime) {
+        const metricsAttributes = {};
+        const keysToCopy = [
+          SemanticAttributes_1.SemanticAttributes.HTTP_RESPONSE_STATUS_CODE,
+          SemanticAttributes_1.SemanticAttributes.HTTP_REQUEST_METHOD,
+          SemanticAttributes_1.SemanticAttributes.SERVER_ADDRESS,
+          SemanticAttributes_1.SemanticAttributes.SERVER_PORT,
+          SemanticAttributes_1.SemanticAttributes.URL_SCHEME,
+          SemanticAttributes_1.SemanticAttributes.ERROR_TYPE
+        ];
+        keysToCopy.forEach((key) => {
+          if (key in attributes) {
+            metricsAttributes[key] = attributes[key];
+          }
+        });
+        const durationSeconds = (0, core_1.hrTimeToMilliseconds)((0, core_1.hrTimeDuration)(startTime, (0, core_1.hrTime)())) / 1e3;
+        this._httpClientDurationHistogram.record(durationSeconds, metricsAttributes);
+      }
+      getRequestMethod(original) {
+        const knownMethods = {
+          CONNECT: true,
+          OPTIONS: true,
+          HEAD: true,
+          GET: true,
+          POST: true,
+          PUT: true,
+          PATCH: true,
+          DELETE: true,
+          TRACE: true
+        };
+        if (original.toUpperCase() in knownMethods) {
+          return original.toUpperCase();
+        }
+        return "_OTHER";
+      }
+    };
+    exports2.UndiciInstrumentation = UndiciInstrumentation2;
+  }
+});
+
+// node_modules/@opentelemetry/instrumentation-undici/build/src/index.js
+var require_src31 = __commonJS({
+  "node_modules/@opentelemetry/instrumentation-undici/build/src/index.js"(exports2) {
+    "use strict";
+    init_esbuild_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.UndiciInstrumentation = void 0;
+    var undici_1 = require_undici();
+    Object.defineProperty(exports2, "UndiciInstrumentation", { enumerable: true, get: /* @__PURE__ */ __name(function() {
+      return undici_1.UndiciInstrumentation;
+    }, "get") });
+  }
+});
+
 // packages/core/src/tools/read-file.ts
 init_esbuild_shims();
 import os4 from "node:os";
@@ -62954,6 +63454,7 @@ import path from "node:path";
 init_esbuild_shims();
 var DEFAULT_CONTEXT_FILENAME = "QWEN.md";
 var AGENT_CONTEXT_FILENAME = "AGENTS.md";
+var LOCAL_CONTEXT_FILENAME = "QWEN.local.md";
 var MEMORY_SECTION_HEADER = "## Qwen Added Memories";
 var currentGeminiMdFilename = [
   DEFAULT_CONTEXT_FILENAME,
@@ -65349,16 +65850,20 @@ __name(isInternalPromptId, "isInternalPromptId");
 // packages/core/src/utils/safeJsonStringify.ts
 init_esbuild_shims();
 function safeJsonStringify(obj, space) {
-  const seen = /* @__PURE__ */ new WeakSet();
+  const ancestors = [];
   return JSON.stringify(
     obj,
-    (key, value) => {
-      if (typeof value === "object" && value !== null) {
-        if (seen.has(value)) {
-          return "[Circular]";
-        }
-        seen.add(value);
+    function(_key, value) {
+      if (typeof value !== "object" || value === null) {
+        return value;
+      }
+      while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+        ancestors.pop();
+      }
+      if (ancestors.includes(value)) {
+        return "[Circular]";
       }
+      ancestors.push(value);
       return value;
     },
     space
@@ -68318,6 +68823,7 @@ var import_sdk_trace_node = __toESM(require_src20(), 1);
 var import_sdk_logs = __toESM(require_src17(), 1);
 var import_sdk_metrics2 = __toESM(require_src9(), 1);
 var import_instrumentation_http = __toESM(require_src30(), 1);
+var import_instrumentation_undici = __toESM(require_src31(), 1);
 
 // packages/core/src/telemetry/file-exporters.ts
 init_esbuild_shims();
@@ -69000,10 +69506,12 @@ function startInteractionSpan(config, options) {
     "qwen-code.approval_mode": config.getApprovalMode(),
     "interaction.sequence": interactionSequence
   };
-  const span = getTracer().startSpan(SPAN_INTERACTION, {
-    kind: SpanKind.INTERNAL,
-    attributes
-  });
+  const sessionCtx = getSessionContext() ?? context.active();
+  const span = getTracer().startSpan(
+    SPAN_INTERACTION,
+    { kind: SpanKind.INTERNAL, attributes },
+    sessionCtx
+  );
   const spanId = getSpanId(span);
   const spanContextObj = {
     span,
@@ -69467,6 +69975,16 @@ function resolveHttpOtlpUrl(baseEndpoint, signal) {
 }
 __name(resolveHttpOtlpUrl, "resolveHttpOtlpUrl");
 var SHUTDOWN_TIMEOUT_MS = 1e4;
+var NOOP_PROPAGATOR = {
+  inject() {
+  },
+  extract(context2) {
+    return context2;
+  },
+  fields() {
+    return [];
+  }
+};
 var sdk;
 var telemetryInitialized = false;
 var telemetryShutdownPromise;
@@ -69619,16 +70137,98 @@ function initializeTelemetry(config) {
       exportIntervalMillis: 1e4
     });
   }
+  function normalizeOtlpPrefix(raw) {
+    if (!raw) return void 0;
+    const s = raw.trim().replace(/^["']|["']$/g, "");
+    try {
+      const u = new URL(s);
+      const pathname = u.pathname === "/" ? "" : u.pathname.replace(/\/$/, "");
+      return { origin: u.origin, pathname };
+    } catch {
+      diag.warn(
+        `Telemetry OTLP endpoint "${raw}" is not a valid URL; instrumentation feedback-loop guard for it is disabled.`
+      );
+      return void 0;
+    }
+  }
+  __name(normalizeOtlpPrefix, "normalizeOtlpPrefix");
+  const otlpUrlPrefixes = [
+    config.getTelemetryOtlpEndpoint(),
+    config.getTelemetryOtlpTracesEndpoint(),
+    config.getTelemetryOtlpLogsEndpoint(),
+    config.getTelemetryOtlpMetricsEndpoint()
+  ].map(normalizeOtlpPrefix).filter((u) => !!u);
+  const matchesOtlpPrefix = /* @__PURE__ */ __name((origin, path8) => {
+    for (const prefix of otlpUrlPrefixes) {
+      if (origin !== prefix.origin) continue;
+      if (prefix.pathname === "") return true;
+      if (!path8.startsWith(prefix.pathname)) continue;
+      const next = path8.charAt(prefix.pathname.length);
+      if (next === "" || next === "/" || next === "?" || next === "#") {
+        return true;
+      }
+    }
+    return false;
+  }, "matchesOtlpPrefix");
+  const stripPathSuffix = /* @__PURE__ */ __name((path8) => {
+    const qIdx = path8.indexOf("?");
+    const fIdx = path8.indexOf("#");
+    let cut = path8.length;
+    if (qIdx !== -1) cut = Math.min(cut, qIdx);
+    if (fIdx !== -1) cut = Math.min(cut, fIdx);
+    return path8.slice(0, cut);
+  }, "stripPathSuffix");
+  const textMapPropagator = config.getOutboundCorrelationPropagateTraceContext() ? void 0 : NOOP_PROPAGATOR;
   sdk = new import_sdk_node.NodeSDK({
     resource,
     // Disable async host/process/env resource detectors: they leave attributes
     // pending and trigger an OTel diag.error on any resource attribute read
     // before the detectors settle (e.g. during HttpInstrumentation span creation).
     autoDetectResources: false,
+    ...textMapPropagator && { textMapPropagator },
     spanProcessors: spanExporter ? [new import_sdk_trace_node.BatchSpanProcessor(spanExporter)] : [],
     logRecordProcessors: logExporter ? [new import_sdk_logs.BatchLogRecordProcessor(logExporter)] : logToSpanProcessor ? [logToSpanProcessor] : [],
     ...metricReader && { metricReader },
-    instrumentations: [new import_instrumentation_http.HttpInstrumentation()]
+    instrumentations: [
+      new import_instrumentation_http.HttpInstrumentation({
+        // OTLP HTTP exporter uses node:http (patched here, not by undici).
+        // Without this, every OTLP upload batch creates a parasitic client
+        // span that itself gets exported → feedback loop. See PR #4390
+        // review feedback (wenshao).
+        ignoreOutgoingRequestHook: /* @__PURE__ */ __name((req) => {
+          if (otlpUrlPrefixes.length === 0) return false;
+          const proto = req.protocol ? String(req.protocol).replace(/:$/, "") : void 0;
+          if (!proto) return false;
+          let host = req.hostname || "";
+          if (!host && req.host) {
+            const h = String(req.host);
+            const bracketEnd = h.indexOf("]");
+            const portIdx = bracketEnd !== -1 ? h.indexOf(":", bracketEnd) : h.indexOf(":");
+            host = portIdx !== -1 ? h.slice(0, portIdx) : h;
+          }
+          const portPart = req.port !== void 0 && req.port !== null && String(req.port) ? `:${req.port}` : "";
+          let origin;
+          try {
+            origin = new URL(`${proto}://${host}${portPart}`).origin;
+          } catch {
+            return false;
+          }
+          const path8 = typeof req.path === "string" ? stripPathSuffix(req.path) : "";
+          return matchesOtlpPrefix(origin, path8);
+        }, "ignoreOutgoingRequestHook")
+      }),
+      // Modern fetch (`globalThis.fetch` / undici) is the HTTP layer used by
+      // `openai`, `@google/genai`, and `@anthropic-ai/sdk`. Without this
+      // instrumentation, outbound LLM requests carry no `traceparent` header
+      // and the trace tree terminates at the qwen-code process boundary.
+      new import_instrumentation_undici.UndiciInstrumentation({
+        ignoreRequestHook: /* @__PURE__ */ __name((request4) => {
+          if (otlpUrlPrefixes.length === 0) return false;
+          const path8 = typeof request4.path === "string" ? stripPathSuffix(request4.path) : "";
+          return matchesOtlpPrefix(request4.origin, path8);
+        }, "ignoreRequestHook")
+      })
+    ]
   });
   try {
     sdk.start();
@@ -71430,12 +72030,48 @@ var ModelsConfig = class _ModelsConfig {
       await this.switchModel(this.currentAuthType, newModel);
       return;
     }
-    this.strictModelProviderSelection = false;
-    this._generationConfig.model = newModel;
-    this.generationConfigSources["model"] = {
-      kind: "programmatic",
-      detail: metadata?.reason || "setModel"
-    };
+    const rollbackSnapshot = this.createStateSnapshotForRollback();
+    try {
+      this.strictModelProviderSelection = false;
+      this._generationConfig.model = newModel;
+      this.generationConfigSources["model"] = {
+        kind: "programmatic",
+        detail: metadata?.reason || "setModel"
+      };
+      this.applyRawModelDerivedDefaults(newModel);
+      if (this.onModelChange && this.currentAuthType) {
+        await this.onModelChange(this.currentAuthType, true);
+      }
+    } catch (error) {
+      this.rollbackToStateSnapshot(rollbackSnapshot);
+      throw error;
+    }
+  }
+  /**
+   * Raw model switches keep the current credentials, but model-derived
+   * generation defaults must follow the new model. Otherwise a switch from a
+   * multimodal registry model to a text-only raw model can keep stale image
+   * support and send unsupported inline media.
+   */
+  applyRawModelDerivedDefaults(modelId) {
+    if (this.shouldUpdateModelDerivedDefault("modalities")) {
+      this._generationConfig.modalities = defaultModalities(modelId);
+      this.generationConfigSources["modalities"] = {
+        kind: "computed",
+        detail: "auto-detected from model"
+      };
+    }
+    if (this.shouldUpdateModelDerivedDefault("contextWindowSize")) {
+      this._generationConfig.contextWindowSize = tokenLimit(modelId, "input");
+      this.generationConfigSources["contextWindowSize"] = {
+        kind: "computed",
+        detail: "auto-detected from model"
+      };
+    }
+  }
+  shouldUpdateModelDerivedDefault(field) {
+    const source = this.generationConfigSources[field];
+    return source === void 0 || source.kind === "computed" || source.kind === "default" || source.kind === "modelProviders" || source.kind === "programmatic" || source.kind === "unknown";
   }
   /**
    * Switch model (and optionally authType).
@@ -72210,11 +72846,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   }
   let baseGenerator;
   if (authType === "openai" /* USE_OPENAI */) {
-    const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-BSAWHGQJ.js");
+    const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-JH4YNZ3H.js");
     baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
   } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-    const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-EEJGROP7.js");
-    const { QwenContentGenerator } = await import("./qwenContentGenerator-47XRHQXM.js");
+    const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-BAN2EGSH.js");
+    const { QwenContentGenerator } = await import("./qwenContentGenerator-5FE4UYUT.js");
     try {
       const qwenClient = await getQwenOauthClient(
         config,
@@ -72231,10 +72867,10 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       );
     }
   } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-    const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-RQJNXJIY.js");
+    const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-LYI3OHBB.js");
     baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
   } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-    const { createGeminiContentGenerator } = await import("./geminiContentGenerator-E7Y6TCPU.js");
+    const { createGeminiContentGenerator } = await import("./geminiContentGenerator-LM65ADWM.js");
     baseGenerator = createGeminiContentGenerator(generatorConfig, config);
   } else {
     throw new Error(
@@ -74265,6 +74901,7 @@ export {
   isUtf8CompatibleEncoding,
   DEFAULT_CONTEXT_FILENAME,
   AGENT_CONTEXT_FILENAME,
+  LOCAL_CONTEXT_FILENAME,
   MEMORY_SECTION_HEADER,
   setGeminiMdFilename,
   getCurrentGeminiMdFilename,