@uipath/common 1.199.0-preview.97 → 1.200.0-preview.109

package/dist/index.js

@@ -3194,6 +3194,9 @@ async function extractErrorDetails(error, options) {
         if (!extractedMessage) {
           extractedMessage = body;
         }
+        if (extractedMessage && typeof parsedBody.detail === "string" && parsedBody.detail.length > 0 && !extractedMessage.includes(parsedBody.detail)) {
+          extractedMessage = `${extractedMessage}: ${parsedBody.detail}`;
+        }
       } else {
         extractedMessage = isHtmlDocument(body) ? HTML_RESPONSE_MESSAGE : body;
       }
@@ -3248,6 +3251,8 @@ async function extractErrorDetails(error, options) {
       const extra = {};
       if (parsedBody.errorCode)
         extra.errorCode = parsedBody.errorCode;
+      if (parsedBody.detail)
+        extra.detail = parsedBody.detail;
       if (parsedBody.details)
         extra.details = parsedBody.details;
       if (parsedBody.errors != null)
@@ -6454,7 +6459,7 @@ function requireOmap() {
   function resolveYamlOmap(data) {
     if (data === null)
       return true;
-    const objectKeys = [];
+    const objectKeys = {};
     const object = data;
     for (let index = 0, length = object.length;index < length; index += 1) {
       const pair = object[index];
@@ -6472,10 +6477,9 @@ function requireOmap() {
       }
       if (!pairHasKey)
         return false;
-      if (objectKeys.indexOf(pairKey) === -1)
-        objectKeys.push(pairKey);
-      else
+      if (_hasOwnProperty.call(objectKeys, pairKey))
         return false;
+      Object.defineProperty(objectKeys, pairKey, { value: true });
     }
     return true;
   }
@@ -9145,9 +9149,12 @@ function buildCommandTerminalTelemetryProperties(input) {
 // src/telemetry/telemetry-events.ts
 var CommonTelemetryEvents = {
   Error: "uip.error",
-  ShipSucceeded: "ship_succeeded"
+  ShipSucceeded: "uip.ship.succeeded"
 };
 
+// src/telemetry/telemetry-init.ts
+import { spawn } from "node:child_process";
+
 // src/registry.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 function readRegistryValue(keyPath, valueName) {
@@ -9476,8 +9483,18 @@ function getInboundTraceContext() {
 
 // src/telemetry/session-id.ts
 var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID";
-var TELEMETRY_SESSION_ID_PROPERTY = "session_id";
-var telemetrySessionIdSlot = singleton("TelemetrySessionId");
+var SESSION_ID_MAX_LENGTH = 64;
+var RANDOM_SESSION_ID_LENGTH = 32;
+var TELEMETRY_SESSION_SOURCE_PROPERTY = "session_id_source";
+var CONTROL_CHARACTERS = /\p{Cc}/gu;
+var INHERITED_SESSION_SOURCES = [
+  { envVar: "CLAUDE_CODE_SESSION_ID", source: "claude-code" },
+  { envVar: "CODEX_THREAD_ID", source: "codex" },
+  { envVar: "ANTIGRAVITY_TRAJECTORY_ID", source: "antigravity" },
+  { envVar: "TERM_SESSION_ID", source: "terminal" },
+  { envVar: "WT_SESSION", source: "terminal" }
+];
+var telemetrySessionSlot = singleton("TelemetrySession");
 var telemetryOperationIdSlot = singleton("TelemetryOperationId");
 function getProcessEnv2() {
   return globalThis.process?.env;
@@ -9486,27 +9503,45 @@ function normalizeSessionId(value) {
   if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
     return;
   }
-  const trimmed = String(value).trim();
-  return trimmed || undefined;
+  const cleaned = String(value).replace(CONTROL_CHARACTERS, "").trim().slice(0, SESSION_ID_MAX_LENGTH);
+  return cleaned || undefined;
 }
 function getConfiguredTelemetrySessionId() {
   return normalizeSessionId(getProcessEnv2()?.[TELEMETRY_SESSION_ID_ENV]);
 }
-function getTelemetrySessionId() {
-  const envSessionId = getConfiguredTelemetrySessionId();
-  if (envSessionId) {
-    return envSessionId;
+function getInheritedSession(env) {
+  for (const candidate of INHERITED_SESSION_SOURCES) {
+    const handle = normalizeSessionId(env[candidate.envVar]);
+    if (handle) {
+      return { id: handle, source: candidate.source };
+    }
   }
-  const existing = telemetrySessionIdSlot.get();
+  return;
+}
+function generateRandomSession() {
+  const bytes = new Uint8Array(RANDOM_SESSION_ID_LENGTH / 2);
+  crypto.getRandomValues(bytes);
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return { id: hex, source: "random" };
+}
+function resolveTelemetrySession() {
+  const existing = telemetrySessionSlot.get();
   if (existing) {
     return existing;
   }
-  const generated = crypto.randomUUID();
-  telemetrySessionIdSlot.set(generated);
-  return generated;
+  const declaredHandle = getConfiguredTelemetrySessionId();
+  const resolved = declaredHandle ? { id: declaredHandle, source: "declared" } : getInheritedSession(getProcessEnv2() ?? {}) ?? generateRandomSession();
+  telemetrySessionSlot.set(resolved);
+  return resolved;
 }
-function resolveTelemetrySessionId(existingSessionId) {
-  return getConfiguredTelemetrySessionId() ?? normalizeSessionId(existingSessionId);
+function getTelemetrySessionId() {
+  return resolveTelemetrySession().id;
+}
+function getTelemetrySessionSource() {
+  return resolveTelemetrySession().source;
 }
 function getTelemetryOperationId() {
   const existing = telemetryOperationIdSlot.get();
@@ -9759,14 +9794,11 @@ class TelemetryService {
   }
   async trackDependencyOperation(name, type2, fn, properties) {
     const parentContext = this.getCurrentContext();
-    if (!parentContext) {
-      throw new Error("trackDependencyOperation must be called within a trackRequest block.");
-    }
-    const childContext = {
+    const childContext = parentContext !== undefined ? {
       operationId: parentContext.operationId,
       parentId: parentContext.id,
       id: this.generateId()
-    };
+    } : this.createRequestContext();
     const startTime = performance.now();
     try {
       const result = await this.contextStorage.run(childContext, fn);
@@ -9787,24 +9819,18 @@ class TelemetryService {
   }
   enrichPropertiesWithContext(properties, context) {
     const globalProperties = getGlobalTelemetryProperties();
-    const existingSessionId = properties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? this.defaultProperties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? globalProperties?.[TELEMETRY_SESSION_ID_PROPERTY];
-    const sessionId = resolveTelemetrySessionId(existingSessionId);
     const enriched = {
       ...getExecutionContextTelemetryProperties(),
       ...globalProperties,
       ...this.defaultProperties,
       ...redactProperties(properties ?? {}),
+      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
       ...context ? {
         [TELEMETRY_OPERATION_ID_PROPERTY]: context.operationId,
         ...context.parentId !== undefined ? { [TELEMETRY_PARENT_ID_PROPERTY]: context.parentId } : {},
         [TELEMETRY_SPAN_ID_PROPERTY]: context.id
       } : {}
     };
-    if (sessionId === undefined) {
-      delete enriched[TELEMETRY_SESSION_ID_PROPERTY];
-    } else {
-      enriched[TELEMETRY_SESSION_ID_PROPERTY] = sessionId;
-    }
     return enriched;
   }
   generateId() {
@@ -9953,6 +9979,9 @@ function normalizeFlushCallbackError(response) {
   }
   return extractAppInsightsDumpMessage(text) ?? text;
 }
+function channelInternals(client) {
+  return client.channel;
+}
 function setDefaultAppInsightsEnv(name, value) {
   if (process.env[name] === undefined) {
     process.env[name] = value;
@@ -10042,16 +10071,6 @@ class NodeAppInsightsTelemetryProvider {
     }
     return { operationId, parentId, spanId };
   }
-  promoteSessionTag(merged, tags) {
-    const client = this.client;
-    if (!client || !merged)
-      return;
-    const sessionId = merged[TELEMETRY_SESSION_ID_PROPERTY];
-    delete merged[TELEMETRY_SESSION_ID_PROPERTY];
-    if (sessionId) {
-      tags[client.context.keys.sessionId] = sessionId;
-    }
-  }
   leafTagOverrides(properties) {
     const client = this.client;
     if (!client)
@@ -10064,7 +10083,6 @@ class NodeAppInsightsTelemetryProvider {
     if (spanId) {
       tags[keys.operationParentId] = spanId;
     }
-    this.promoteSessionTag(properties, tags);
     return tags;
   }
   operationCorrelation(properties) {
@@ -10079,7 +10097,6 @@ class NodeAppInsightsTelemetryProvider {
     if (parentId) {
       tagOverrides[keys.operationParentId] = parentId;
     }
-    this.promoteSessionTag(properties, tagOverrides);
     return { tagOverrides, id: spanId };
   }
   async trackEvent(eventName, properties) {
@@ -10172,6 +10189,32 @@ class NodeAppInsightsTelemetryProvider {
       logger.warn(`[AppInsights] flush error (non-fatal): ${error.message}`);
     }
   }
+  drainPendingEnvelopes() {
+    const client = this.client;
+    if (!client)
+      return;
+    const endpointUrl = client.config?.endpointUrl;
+    if (!endpointUrl)
+      return;
+    const [error, envelopes] = catchError(() => {
+      const channel = channelInternals(client);
+      if (!channel || !Array.isArray(channel._buffer)) {
+        throw new Error("unexpected channel shape");
+      }
+      if (channel._timeoutHandle) {
+        clearTimeout(channel._timeoutHandle);
+        channel._timeoutHandle = undefined;
+      }
+      const buffered = channel._buffer;
+      channel._buffer = [];
+      return buffered;
+    });
+    if (error) {
+      logger.debug("[AppInsights] failed to drain the channel buffer");
+      return;
+    }
+    return { endpointUrl, envelopes };
+  }
   async shutdown() {
     const client = this.client;
     if (client) {
@@ -10179,6 +10222,19 @@ class NodeAppInsightsTelemetryProvider {
       if (statsbeatError) {
         logger.debug("[AppInsights] failed to shut down Statsbeat");
       }
+      const [channelError] = catchError(() => {
+        const channel = channelInternals(client);
+        if (!channel)
+          return;
+        if (channel._timeoutHandle) {
+          clearTimeout(channel._timeoutHandle);
+          channel._timeoutHandle = undefined;
+        }
+        channel._buffer = [];
+      });
+      if (channelError) {
+        logger.debug("[AppInsights] failed to clear the channel buffer");
+      }
     }
     const appInsights = this.appInsightsModule;
     if (appInsights) {
@@ -10220,6 +10276,115 @@ function isTelemetryDisabled() {
   return value === "1" || value === "true";
 }
 
+// src/telemetry/telemetry-spool.ts
+var TELEMETRY_DRAIN_ARGV = "__uip-drain-telemetry";
+var sidecarEntrySlot = singleton("TelemetrySidecarEntry");
+function setTelemetrySidecarEntry(entryPath) {
+  sidecarEntrySlot.set(entryPath);
+}
+function getTelemetrySidecarEntry() {
+  return sidecarEntrySlot.get();
+}
+var PENDING_SUFFIX = ".json";
+var CLAIMED_SUFFIX = ".sending";
+var WRITE_TEMP_SUFFIX = ".tmp";
+var MAX_SPOOL_AGE_MS = 72 * 60 * 60 * 1000;
+var MAX_SPOOL_FILES = 50;
+function getTelemetrySpoolDir() {
+  const fs7 = getFileSystem();
+  return fs7.path.join(fs7.env.homedir(), ".uipath", "telemetry", "pending");
+}
+async function writeTelemetrySpoolFile(payload) {
+  const fs7 = getFileSystem();
+  const dir = getTelemetrySpoolDir();
+  await fs7.mkdir(dir);
+  const name = `${Date.now()}-${process.pid}`;
+  const finalPath = fs7.path.join(dir, `${name}${PENDING_SUFFIX}`);
+  const tempPath = fs7.path.join(dir, `${name}${WRITE_TEMP_SUFFIX}`);
+  await fs7.writeFile(tempPath, JSON.stringify(payload));
+  await fs7.rename(tempPath, finalPath);
+  return finalPath;
+}
+function isSpoolPayload(value) {
+  return value !== null && typeof value === "object" && typeof value.endpointUrl === "string" && value.endpointUrl.length > 0 && Array.isArray(value.envelopes);
+}
+async function listSpoolEntries(suffix) {
+  const fs7 = getFileSystem();
+  const dir = getTelemetrySpoolDir();
+  const [readdirError, names] = await catchError(fs7.readdir(dir));
+  if (readdirError) {
+    return { dir, names: [] };
+  }
+  return {
+    dir,
+    names: names.filter((n) => n.endsWith(suffix)).sort((a, b) => a.localeCompare(b))
+  };
+}
+async function claimPendingSpoolFiles() {
+  const fs7 = getFileSystem();
+  const { dir, names } = await listSpoolEntries(PENDING_SUFFIX);
+  const claimed = [];
+  for (const name of names) {
+    const pendingPath = fs7.path.join(dir, name);
+    const claimedPath = `${pendingPath.slice(0, -PENDING_SUFFIX.length)}${CLAIMED_SUFFIX}`;
+    const [claimError] = await catchError(fs7.rename(pendingPath, claimedPath));
+    if (claimError) {
+      continue;
+    }
+    const [readError, raw] = await catchError(fs7.readFile(claimedPath, "utf-8"));
+    if (readError || raw === null) {
+      logger.debug(`[TelemetrySpool] could not read ${name}; leaving it for a later run`);
+      await releaseClaimedSpoolFile(claimedPath);
+      continue;
+    }
+    const [parseError, parsed] = catchError(() => JSON.parse(raw));
+    if (parseError || !isSpoolPayload(parsed)) {
+      logger.debug(`[TelemetrySpool] dropping malformed file: ${name}`);
+      await catchError(fs7.rm(claimedPath));
+      continue;
+    }
+    claimed.push({ claimedPath, payload: parsed });
+  }
+  return claimed;
+}
+async function releaseClaimedSpoolFile(claimedPath) {
+  const fs7 = getFileSystem();
+  const pendingPath = `${claimedPath.slice(0, -CLAIMED_SUFFIX.length)}${PENDING_SUFFIX}`;
+  await catchError(fs7.rename(claimedPath, pendingPath));
+}
+async function discardClaimedSpoolFile(claimedPath) {
+  const fs7 = getFileSystem();
+  await catchError(fs7.rm(claimedPath));
+}
+async function sweepTelemetrySpool() {
+  const fs7 = getFileSystem();
+  const { dir, names } = await listSpoolEntries("");
+  const now = Date.now();
+  const pending = [];
+  for (const name of names) {
+    const filePath = fs7.path.join(dir, name);
+    const [statError, stats] = await catchError(fs7.stat(filePath));
+    if (statError || !stats) {
+      continue;
+    }
+    if (now - stats.mtimeMs > MAX_SPOOL_AGE_MS) {
+      await catchError(fs7.rm(filePath));
+      continue;
+    }
+    if (name.endsWith(PENDING_SUFFIX)) {
+      pending.push({ path: filePath, mtimeMs: stats.mtimeMs });
+    }
+  }
+  if (pending.length > MAX_SPOOL_FILES) {
+    pending.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    const excess = pending.slice(0, pending.length - MAX_SPOOL_FILES);
+    for (const file of excess) {
+      await catchError(fs7.rm(file.path));
+    }
+    logger.debug(`[TelemetrySpool] deleted ${excess.length} oldest files over the ${MAX_SPOOL_FILES}-file cap`);
+  }
+}
+
 // src/telemetry/telemetry-init.ts
 var telemetryInstanceSlot = singleton("TelemetryService");
 var DEFAULT_AI_CONNECTION_STRING = atob("SW5zdHJ1bWVudGF0aW9uS2V5PTliZDM3NDgyLTgxMGUtNDQyYS1hYWE2LWQzOGVmNjVjNjY3NDtJbmdlc3Rpb25FbmRwb2ludD1odHRwczovL3dlc3RldXJvcGUtNS5pbi5hcHBsaWNhdGlvbmluc2lnaHRzLmF6dXJlLmNvbS87TGl2ZUVuZHBvaW50PWh0dHBzOi8vd2VzdGV1cm9wZS5saXZlZGlhZ25vc3RpY3MubW9uaXRvci5henVyZS5jb20vO0FwcGxpY2F0aW9uSWQ9MzU2OTdlZjEtOGJkMC00ZjE5LWEyN2MtZDg3Y2NhYzY2ZDJj");
@@ -10313,6 +10478,56 @@ async function runWithTimeout(operation, timeoutMs) {
       clearTimeout(timer);
   }
 }
+async function runProviderShutdown(provider) {
+  const [shutdownError, shutdownResult] = await catchError(runWithTimeout(provider.shutdown(), FLUSH_SHUTDOWN_TIMEOUT_MS));
+  if (shutdownError) {
+    logger.warn(`[Telemetry] shutdown failed (non-fatal): ${shutdownError.message}`);
+  } else if (shutdownResult === "timeout") {
+    logger.warn(`[Telemetry] shutdown timed out after ${FLUSH_SHUTDOWN_TIMEOUT_MS}ms`);
+  }
+}
+function isSyncFlushForced() {
+  const value = process.env.UIPATH_TELEMETRY_SYNC_FLUSH;
+  return value === "1" || value === "true";
+}
+function isDrainableTelemetryProvider(provider) {
+  return "drainPendingEnvelopes" in provider && typeof provider.drainPendingEnvelopes === "function";
+}
+function spawnTelemetrySidecar(entryPath) {
+  const child = spawn(process.execPath, [entryPath, TELEMETRY_DRAIN_ARGV], {
+    cwd: getFileSystem().env.tmpdir(),
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  });
+  child.on("error", (error) => {
+    logger.debug(`[Telemetry] sidecar spawn failed (spool kept for a later run): ${error.message}`);
+  });
+  child.unref();
+}
+async function trySidecarHandoff(provider) {
+  const entryPath = getTelemetrySidecarEntry();
+  if (entryPath === undefined || isSyncFlushForced() || !isDrainableTelemetryProvider(provider)) {
+    return false;
+  }
+  const pending = provider.drainPendingEnvelopes();
+  if (!pending) {
+    return false;
+  }
+  if (pending.envelopes.length > 0) {
+    const [spoolError] = await catchError(writeTelemetrySpoolFile(pending));
+    if (spoolError) {
+      logger.debug(`[Telemetry] spool write failed; dropping ${pending.envelopes.length} pending envelope(s): ${spoolError.message}`);
+    } else {
+      const [spawnError] = catchError(() => spawnTelemetrySidecar(entryPath));
+      if (spawnError) {
+        logger.debug(`[Telemetry] sidecar spawn failed; spool will be sent by a future run: ${spawnError.message}`);
+      }
+    }
+  }
+  await runProviderShutdown(provider);
+  return true;
+}
 async function telemetryFlushAndShutdown() {
   if (!isFlushableTelemetryProvider(telemetryProviderInstance)) {
     return;
@@ -10320,22 +10535,27 @@ async function telemetryFlushAndShutdown() {
   if (!telemetryFlushShutdownPromise) {
     const provider = telemetryProviderInstance;
     telemetryFlushShutdownPromise = (async () => {
+      if (await trySidecarHandoff(provider)) {
+        return;
+      }
       const [flushError, flushResult] = await catchError(runWithTimeout(provider.flush(), FLUSH_SHUTDOWN_TIMEOUT_MS));
       if (flushError) {
         logger.warn(`[Telemetry] flush failed (non-fatal): ${flushError.message}`);
       } else if (flushResult === "timeout") {
         logger.warn(`[Telemetry] flush timed out after ${FLUSH_SHUTDOWN_TIMEOUT_MS}ms`);
       }
-      const [shutdownError, shutdownResult] = await catchError(runWithTimeout(provider.shutdown(), FLUSH_SHUTDOWN_TIMEOUT_MS));
-      if (shutdownError) {
-        logger.warn(`[Telemetry] shutdown failed (non-fatal): ${shutdownError.message}`);
-      } else if (shutdownResult === "timeout") {
-        logger.warn(`[Telemetry] shutdown timed out after ${FLUSH_SHUTDOWN_TIMEOUT_MS}ms`);
-      }
+      await runProviderShutdown(provider);
     })();
   }
   await telemetryFlushShutdownPromise;
 }
+async function telemetryShutdownWithoutFlush() {
+  if (!isFlushableTelemetryProvider(telemetryProviderInstance)) {
+    return;
+  }
+  telemetryFlushShutdownPromise ??= runProviderShutdown(telemetryProviderInstance);
+  await telemetryFlushShutdownPromise;
+}
 
 // src/formatter.ts
 var CLI_ERROR_CODES = [
@@ -10612,21 +10832,43 @@ function printTable(data, logFn, externalLogValue) {
     logFn(`Log: ${externalLogValue}`);
   }
 }
+function isPlainObjectArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isPlainRecord);
+}
+function isNonEmptyPlainObject(value) {
+  return isPlainRecord(value) && Object.keys(value).length > 0;
+}
+var NESTED_INDENT = "  ";
 function printVerticalTable(data, logFn = console.log, externalLogValue) {
   const keys = Object.keys(data).filter((key) => !["code", "log"].includes(key.toLowerCase()));
   if (keys.length === 0)
     return;
-  const maxKeyWidth = Math.max(...keys.map((key) => key.length));
+  const isBlockValue = (value) => isPlainObjectArray(value) || isNonEmptyPlainObject(value);
+  const scalarKeys = keys.filter((key) => !isBlockValue(data[key]));
+  const maxKeyWidth = scalarKeys.length > 0 ? Math.max(...scalarKeys.map((key) => key.length)) : 0;
+  const termWidth = process.stdout.columns || 120;
+  const nestedWidth = Math.max(termWidth - NESTED_INDENT.length, 1);
   keys.forEach((key) => {
+    const value = data[key];
+    if (isPlainObjectArray(value)) {
+      logFn(`${key}:`);
+      printResizableTable(value, (line) => logFn(`${NESTED_INDENT}${line}`), undefined, nestedWidth);
+      return;
+    }
+    if (isNonEmptyPlainObject(value)) {
+      logFn(`${key}:`);
+      printVerticalTable(value, (line) => logFn(`${NESTED_INDENT}${line}`));
+      return;
+    }
     const keyCol = key.padEnd(maxKeyWidth);
-    logFn(`${keyCol} | ${cellToString(data[key])}`);
+    logFn(`${keyCol} | ${cellToString(value)}`);
   });
   if (externalLogValue) {
     logFn("");
     logFn(`Log: ${externalLogValue}`);
   }
 }
-function printResizableTable(data, logFn = console.log, externalLogValue) {
+function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth) {
   if (data.length === 0)
     return;
   const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
@@ -10639,7 +10881,7 @@ function printResizableTable(data, logFn = console.log, externalLogValue) {
   const naturalWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
   const separatorTotal = (keys.length - 1) * 3;
   const totalWidth = naturalWidths.reduce((a, b) => a + b, 0) + separatorTotal;
-  const termWidth = process.stdout.columns || 120;
+  const termWidth = availableWidth ?? (process.stdout.columns || 120);
   if (totalWidth <= termWidth) {
     printTable(data, logFn, externalLogValue);
     return;
@@ -10729,6 +10971,19 @@ class FilterEvaluationError extends Error {
     this.instructions = `The --output-filter expression '${filter}' failed at evaluation time. ` + "Note that --output-filter operates on the 'Data' field of the envelope, not the full object. " + "For example, on a list result use 'length(@)' instead of 'Data | length(@)'.";
   }
 }
+
+class FilterImplicitLimitError extends Error {
+  __brand = "FilterImplicitLimitError";
+  errorCode = "invalid_argument";
+  instructions;
+  retry = "RetryWillNotFix";
+  result = RESULTS.ValidationError;
+  constructor(defaultLimit) {
+    super(`--output-filter requires an explicit --limit: this command defaults to --limit ${defaultLimit}, ` + `so the filter would silently apply to only the first ${defaultLimit} records.`);
+    this.name = "FilterImplicitLimitError";
+    this.instructions = "Pass --limit <n> to choose how many records the filter applies to. " + "To filter over all records, pass the command's maximum accepted --limit (see the option's description in --help).";
+  }
+}
 function applyFilter(data, filter) {
   let result;
   try {
@@ -10982,7 +11237,7 @@ var COMMAND_ATTRIBUTION = commandAttribution([
   ["agents", "build", ["uip.codedagent", "uip.agent"]],
   ["agenthub", "build", ["uip.agenthub"]],
   ["coded-apps", "build", ["uip.codedapp"]],
-  ["functions", "build", ["uip.functions"]],
+  ["functions", "build", ["uip.function", "uip.functions"]],
   ["solution", "build", ["uip.solution"]],
   ["maestro", "build", ["uip.maestro", "uip.case", "uip.flow"]],
   ["llm-observability", "troubleshoot", ["uip.traces"]],
@@ -11149,6 +11404,16 @@ function commandHelpHint(commandPath) {
 function isPromptCancellation(error) {
   return error instanceof Error && error.name === "ExitPromptError";
 }
+function implicitLimitViolation(cmd) {
+  if (getOutputFilter() === undefined) {
+    return;
+  }
+  const hasLimit = cmd.options.some((o) => o.attributeName() === "limit");
+  if (!hasLimit || cmd.getOptionValueSource("limit") !== "default") {
+    return;
+  }
+  return new FilterImplicitLimitError(String(cmd.opts().limit));
+}
 function exitCodeFromProcess(fallback) {
   return typeof process.exitCode === "number" ? process.exitCode : fallback;
 }
@@ -11162,7 +11427,13 @@ Command.prototype.trackedAction = function(context, fn, properties) {
     let errorMessage;
     let fallbackExitCode = EXIT_CODES.Success;
     clearRecordedCommandFailureTelemetry();
-    const [error] = await catchError(telemetry.runWithContext(requestContext, () => fn(...args)));
+    const [error] = await catchError(telemetry.runWithContext(requestContext, () => {
+      const violation = implicitLimitViolation(command);
+      if (violation) {
+        return Promise.reject(violation);
+      }
+      return fn(...args);
+    }));
     if (error) {
       errorMessage = error instanceof Error ? error.message : String(error);
       logger.debug(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
@@ -11412,6 +11683,40 @@ var GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$
 function isGuid(value) {
   return GUID_REGEX.test(value);
 }
+// src/host-global-options.ts
+var HOST_GLOBAL_OPTIONS_WITH_VALUE = [
+  "--output",
+  "--output-filter",
+  "--log-level",
+  "--log-file",
+  "--profile"
+];
+var HOST_GLOBAL_FLAGS = [
+  "--json",
+  "--interactive",
+  "--no-interactive"
+];
+var VALUE_OPTIONS = new Set(HOST_GLOBAL_OPTIONS_WITH_VALUE);
+var BOOLEAN_FLAGS = new Set(HOST_GLOBAL_FLAGS);
+function stripHostGlobalOptions(args) {
+  const cleaned = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (BOOLEAN_FLAGS.has(arg)) {
+      continue;
+    }
+    if (VALUE_OPTIONS.has(arg)) {
+      i++;
+      continue;
+    }
+    const equalsIndex = arg.indexOf("=");
+    if (equalsIndex > 0 && VALUE_OPTIONS.has(arg.slice(0, equalsIndex))) {
+      continue;
+    }
+    cleaned.push(arg);
+  }
+  return cleaned;
+}
 // src/interactivity-context.ts
 var modeSlot = singleton("InteractivityMode");
 var interactiveFlagSlot = singleton("InteractiveFlag");
@@ -11575,6 +11880,22 @@ function mapPackageMetadataOptions(opts) {
   }
   return fields;
 }
+// src/packager-tool-import.ts
+var REGISTER_EXPORT = "registerPackagerFactories";
+async function importPackagerTool(specifier) {
+  const [importError, mod2] = await catchError(import(specifier));
+  if (importError)
+    return importError;
+  const register = mod2?.[REGISTER_EXPORT];
+  if (typeof register !== "function") {
+    logger.debug(`'${specifier}' has no '${REGISTER_EXPORT}' export — treating it as a ` + "legacy entry point that registered its factories at import.");
+    return;
+  }
+  const [registerError] = catchError(() => {
+    register();
+  });
+  return registerError;
+}
 // src/polling/abort-controller.ts
 var created = false;
 function createPollAbortController() {
@@ -12061,9 +12382,15 @@ var FAILURE_STATUSES = new Set([
   "stopped"
 ]);
 function isTerminalStatus(status) {
+  if (typeof status !== "string") {
+    return false;
+  }
   return TERMINAL_STATUSES.has(status.toLowerCase());
 }
 function isFailureStatus(status) {
+  if (typeof status !== "string") {
+    return false;
+  }
   return FAILURE_STATUSES.has(status.toLowerCase());
 }
 function isSuccessStatus(status) {
@@ -12205,6 +12532,68 @@ function installSdkUserAgentHeader(BaseApiClass, userAgent) {
 function installSdkCodingAgentHeader(BaseApiClass) {
   installRequestHeaderForwarding(BaseApiClass, codingAgentPatchKey(), (headers) => addSdkCodingAgentHeader(headers));
 }
+// src/tool-module-import.ts
+async function importToolModule(specifier) {
+  return await import(specifier);
+}
+
+// src/tool-provider.ts
+var factorySlot = singleton("PackagerFactoryProvider");
+function setPackagerFactoryProvider(provider) {
+  factorySlot.set(provider);
+}
+var moduleSlot = singleton("ToolModuleProvider");
+function setToolModuleProvider(provider) {
+  moduleSlot.set(provider);
+}
+async function ensureToolModule(verb, packageName, moduleName) {
+  if (!/^[a-z0-9-]+$/.test(moduleName)) {
+    throw new Error(`Invalid tool module name '${moduleName}'.`);
+  }
+  const provider = moduleSlot.get();
+  if (provider) {
+    return provider(verb, moduleName);
+  }
+  const specifier = `${packageName}/${moduleName}`;
+  const [importError, mod2] = await catchError(importToolModule(specifier));
+  if (importError) {
+    logger.debug(`No tool-module provider registered; import of '${specifier}' failed: ${importError.message}`);
+    throw new Error(`This command needs '${packageName}'. Install it.`, {
+      cause: importError
+    });
+  }
+  return mod2;
+}
+async function ensurePackagerFactory(verb, packageName) {
+  const provider = factorySlot.get();
+  if (provider) {
+    await provider(verb);
+    return;
+  }
+  const importError = packageName ? await loadPackagerTool(`${packageName}/packager-tool`) : undefined;
+  if (packageName && !importError)
+    return;
+  throw new Error(packageName ? `Packing this project type needs '${packageName}'. Install it.` : `Packing this project type needs the packager factory for '${verb}', and no package provides it.`, { cause: importError });
+}
+async function loadPackagerTool(specifier) {
+  const error = await importPackagerTool(specifier);
+  if (error) {
+    logger.debug(`No packager factory provider registered; import of '${specifier}' failed: ${error.message}`);
+    return error;
+  }
+  logger.debug(`No packager factory provider registered; loaded '${specifier}' directly.`);
+  return;
+}
+
+// src/solution-project-artifacts.ts
+async function ensureProjectArtifacts(args) {
+  const [error, mod2] = await catchError(ensureToolModule("solution", "@uipath/solution-tool", "init"));
+  if (error) {
+    logger.warn(`Solution artifact-resource generation skipped for project "${args.projectName}": ${error.message}. ` + "Run 'uip solution project add' to finish setup.");
+    return { Created: false, Error: error.message };
+  }
+  return mod2.addProjectArtifactsToSolutionAsync(args);
+}
 // src/stdin.ts
 async function readStdin() {
   if (process.stdin.isTTY) {
@@ -12304,30 +12693,24 @@ function trackShipSucceeded(payload) {
   telemetry.trackEvent(CommonTelemetryEvents.ShipSucceeded, redactProperties({ ...payload }));
   return true;
 }
-// src/tool-provider.ts
-var factorySlot = singleton("PackagerFactoryProvider");
-function setPackagerFactoryProvider(provider) {
-  factorySlot.set(provider);
-}
-async function ensurePackagerFactory(verb) {
-  const provider = factorySlot.get();
-  if (!provider) {
-    throw new Error(`Packager factory for '${verb}' is required but no factory provider is registered. ` + `Run 'uip tools install ${verb}' manually.`);
-  }
-  await provider(verb);
-}
 export {
+  writeTelemetrySpoolFile,
   withCompleter,
   wasInteractiveFlagPassed,
   warnDeprecatedTenantOption,
   warnDeprecatedOptionAlias,
   validateOutputFilter,
   trackShipSucceeded,
+  telemetryShutdownWithoutFlush,
   telemetryInit,
   telemetryFlushAndShutdown,
   telemetry,
   takeRecordedCommandFailureTelemetry,
+  sweepTelemetrySpool,
+  stripHostGlobalOptions,
   singleton,
+  setToolModuleProvider,
+  setTelemetrySidecarEntry,
   setSdkUserAgentHostToken,
   setProcessContextPollSignal,
   setPreviewBuild,
@@ -12346,12 +12729,12 @@ export {
   runValidators,
   runChecks,
   restoreConsole,
-  resolveTelemetrySessionId,
   resolveEnvReference,
   resolveDeprecatedOptionAlias,
   resolveAttachmentInputs,
   resetLoggerInstance,
   requireConfirmation,
+  releaseClaimedSpoolFile,
   registerPackageMetadataOptions,
   redactValue,
   redactProperty,
@@ -12391,6 +12774,9 @@ export {
   installSdkCodingAgentHeader,
   installConsoleGuard,
   hashContent,
+  getTelemetrySpoolDir,
+  getTelemetrySidecarEntry,
+  getTelemetrySessionSource,
   getTelemetrySessionId,
   getSdkUserAgentToken,
   getRecordedCommandFailureTelemetry,
@@ -12414,7 +12800,10 @@ export {
   extractErrorDetails,
   extractCommandHelp,
   escapeNonAscii,
+  ensureToolModule,
+  ensureProjectArtifacts,
   ensurePackagerFactory,
+  discardClaimedSpoolFile,
   detectExecutionContext,
   detectAgentVersion,
   detectAgent,
@@ -12427,6 +12816,7 @@ export {
   configureLogger,
   collectCommands,
   clearRecordedCommandFailureTelemetry,
+  claimPendingSpoolFiles,
   catchError,
   canPrompt,
   buildSkillEventTelemetryAttribution,
@@ -12444,22 +12834,29 @@ export {
   TelemetryService,
   TELEMETRY_TRACEPARENT_ENV,
   TELEMETRY_SPAN_ID_PROPERTY,
-  TELEMETRY_SESSION_ID_PROPERTY,
+  TELEMETRY_SESSION_SOURCE_PROPERTY,
   TELEMETRY_SESSION_ID_ENV,
   TELEMETRY_PARENT_ID_PROPERTY,
   TELEMETRY_OPERATION_ID_PROPERTY,
+  TELEMETRY_DRAIN_ARGV,
   TELEMETRY_COMMAND_ARG_PREFIX,
   SuccessOutput,
   ScreenLogger,
   RETRY_HINTS,
   RESULTS,
+  REGISTER_EXPORT,
   PollOutcome,
   Pagination,
   POLL_DEFAULTS,
   OutputFormatter,
   NodeContextStorage,
   MIN_INTERVAL_MS,
+  MAX_SPOOL_FILES,
+  MAX_SPOOL_AGE_MS,
   LogLevel,
+  HOST_GLOBAL_OPTIONS_WITH_VALUE,
+  HOST_GLOBAL_FLAGS,
+  FilterImplicitLimitError,
   FilterEvaluationError,
   FailureOutput,
   ErrorDecision,
@@ -12483,4 +12880,4 @@ export {
   ATTACHMENT_INSTRUCTIONS
 };
 
-//# debugId=0104AD30EA6F6A7264756E2164756E21
+//# debugId=C8D78C124860EA5264756E2164756E21