@uipath/agent-tool 1.202.0 → 1.203.0-preview.160

package/dist/packager-tool-abj3ftf8.js

@@ -0,0 +1,1751 @@
+import {
+  OutputFormatter,
+  PersonalWorkspacesApi,
+  RESULTS,
+  addSdkUserAgentHeader,
+  catchError,
+  createApiClient,
+  findSolutionFile,
+  getFileSystem,
+  getLoginStatusAsync,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader,
+  logger,
+  readUipxFile,
+  summarizePlatformBody,
+  updateSolutionFile,
+  updateUipxSolutionId
+} from "./packager-tool-tnz82jk0.js";
+import {
+  zipSync
+} from "./packager-tool-b098y4a2.js";
+
+// ../solution-sdk/src/studio-web-compat.ts
+var API_PROJECT_TYPES = new Set(["api", "apiautomation"]);
+
+class StudioWebIncompatibleProjectError extends Error {
+  offendingProjects;
+  constructor(offendingProjects) {
+    super(`Studio Web cannot import API Workflow project(s) manifested by project.json: ${offendingProjects.join(", ")}. Studio Web's solution import accepts only project.uiproj-manifested projects.`);
+    this.offendingProjects = offendingProjects;
+    this.name = "StudioWebIncompatibleProjectError";
+  }
+}
+function assertStudioWebCompatibleProjects(projects) {
+  const incompatible = projects.filter((p) => typeof p.Type === "string" && API_PROJECT_TYPES.has(p.Type.toLowerCase()) && p.ProjectRelativePath.replace(/\\/g, "/").split("/").pop() === "project.json");
+  if (incompatible.length > 0) {
+    throw new StudioWebIncompatibleProjectError(incompatible.map((p) => p.ProjectRelativePath));
+  }
+}
+
+// ../studioweb-sdk/generated/src/runtime.ts
+var BASE_PATH = "https://alpha.uipath.com/studio_/backend".replace(/\/+$/, "");
+
+class Configuration {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig = new Configuration;
+
+class BaseAPI {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+// ../solution-sdk/generated/src/runtime.ts
+var BASE_PATH2 = "https://alpha.uipath.com/uipattycyrhx/abizon_1/automationsolutions_".replace(/\/+$/, "");
+
+class Configuration2 {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH2;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring2;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig2 = new Configuration2;
+
+class BaseAPI2 {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig2) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI2.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError2(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData2(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob2(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError2(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob2(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData2(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError2 extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError2 extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+function querystring2(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey2(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey2(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey2(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring2(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+// ../solution-sdk/package.json
+var package_default = {
+  name: "@uipath/solution-sdk",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.203.0-preview.160",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/solution-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "solution",
+    "sdk"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/src/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/src/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./resources": {
+      types: "./dist/src/resources/index.d.ts",
+      default: "./dist/resources/index.js"
+    },
+    "./auth": {
+      types: "./dist/src/solution-auth.d.ts",
+      default: "./dist/solution-auth.js"
+    }
+  },
+  bin: {
+    "generate-sdk": "./dist/scripts/generate-sdk.js"
+  },
+  files: [
+    "dist"
+  ],
+  private: false,
+  scripts: {
+    build: "bun build ./src/index.ts ./src/resources/index.ts ./src/solution-auth.ts --outdir dist --format esm --target node --splitting --sourcemap=linked && bun build ./src/scripts/generate-sdk.ts --outdir dist/scripts --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    generate: "bun run src/scripts/generate-sdk.ts",
+    lint: "biome check .",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  devDependencies: {
+    "@openapitools/openapi-generator-cli": "^2.31.1",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/orchestrator-sdk": "workspace:*",
+    "@uipath/resource-builder-sdk": "2025.11.0-alpha5891-4020",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/studioweb-sdk": "workspace:*",
+    "@types/node": "^25.5.2",
+    fflate: "^0.8.2",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../solution-sdk/src/user-agent.ts
+var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
+installSdkUserAgentHeader(BaseAPI2, SDK_USER_AGENT);
+
+// ../solution-sdk/src/upload-service.ts
+class SolutionUploadHttpError extends Error {
+  status;
+  operation;
+  method;
+  endpoint;
+  url;
+  body;
+  solutionId;
+  parsedErrorCode;
+  parsedErrorMessage;
+  authChallenge;
+  constructor(details) {
+    super(details.message);
+    this.name = "SolutionUploadHttpError";
+    this.status = details.status;
+    this.operation = details.operation;
+    this.method = details.method;
+    this.endpoint = details.endpoint;
+    this.url = details.url;
+    this.body = details.body;
+    if (details.operation === "overwrite") {
+      this.solutionId = details.solutionId;
+    }
+    this.authChallenge = details.authChallenge;
+    const parsed = parseUploadErrorBody(details.body);
+    this.parsedErrorCode = parsed.code;
+    this.parsedErrorMessage = parsed.message;
+  }
+}
+function parseUploadErrorBody(body) {
+  const [, parsed] = catchError(() => JSON.parse(body));
+  if (!parsed || typeof parsed !== "object")
+    return {};
+  const rawCode = parsed.code ?? parsed.Code;
+  const rawMessage = parsed.message ?? parsed.Message;
+  return {
+    code: typeof rawCode === "string" || typeof rawCode === "number" ? String(rawCode) : undefined,
+    message: typeof rawMessage === "string" && rawMessage.trim() ? rawMessage : undefined
+  };
+}
+function isSolutionUploadHttpError(error) {
+  return error instanceof Error && error.name === "SolutionUploadHttpError" && "operation" in error && (error.operation === "import" || error.operation === "overwrite") && "status" in error && typeof error.status === "number" && "body" in error && typeof error.body === "string";
+}
+function requestPath(url) {
+  const [, parsed] = catchError(() => new URL(url));
+  return parsed ? `${parsed.pathname}${parsed.search}` : url;
+}
+var TOKEN_SHAPED = /\beyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]*)?|\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi;
+function redactTokens(text) {
+  return text.replace(TOKEN_SHAPED, "[REDACTED]");
+}
+var MAX_CHALLENGE_DESCRIPTION = 200;
+function parseAuthChallenge(header) {
+  if (!header)
+    return {};
+  const code = /\berror="([^"]*)"/.exec(header)?.[1]?.trim();
+  const raw = /\berror_description="([^"]*)"/.exec(header)?.[1]?.trim();
+  const description = raw ? redactTokens(raw).slice(0, MAX_CHALLENGE_DESCRIPTION) : undefined;
+  return {
+    error: code || undefined,
+    description: description || undefined
+  };
+}
+function summarizeAuthRefusalBody(body) {
+  return summarizePlatformBody(redactTokens(body));
+}
+function isAuthRefusal(status) {
+  return status === 401 || status === 403;
+}
+function buildAuthRefusalInstructions({
+  err,
+  subject,
+  target,
+  bodySuffix,
+  identityType,
+  clientId
+}) {
+  const refusal = err.status === 401 ? "rejected the call as unauthorized (401)" : "forbade the call (403)";
+  const what = err.operation === "overwrite" ? `replacing the contents of solution ${target}` : "importing the solution package";
+  const actor = identityType === "Application" ? `This session acts as external application ${clientId ?? "(client id unknown)"}, so ` + `check what that application is allowed to do: it needs the Studio ` + `Web scopes that cover writing a solution (the StudioWebS2S grants ` + `on the external application), not just the Orchestrator or ` + `Solutions ones. ` : identityType === "User" ? `This session acts as a user, so check that your account has ` + `Studio Web access in this tenant. ` : `Check what this session is allowed to do in Studio Web — an ` + `external application needs the StudioWebS2S grants that cover ` + `writing a solution, a user needs Studio Web access in the tenant. `;
+  const tenant = err.operation === "overwrite" ? `Also confirm that ${target} is the solution this project should ` + `publish to, and that it lives in the organization and tenant ` + `this session logged into — the id comes from the SolutionId ` + `recorded in the enclosing solution file. An id this session ` + `cannot see at all is reported separately, as nothing to ` + `overwrite, so a refusal here points at the grants first. ` : `Also confirm you are logged into the organization and tenant the ` + `solution should land in. `;
+  const challenge = parseAuthChallenge(err.authChallenge);
+  const quoted = challenge.description ? ` ("${challenge.description}")` : "";
+  if (challenge.error === "invalid_token") {
+    return `Studio Web ${refusal} while ${what}, and rejected the credential ` + `itself with the reason \`invalid_token\`${quoted}. That is the ` + `platform refusing this token rather than the permissions behind ` + `it, so unlike a grants refusal this one is worth a fresh ` + `\`uip login\` — or, in a pipeline, a newly minted ` + `client-credentials token. Check too that the token was issued for ` + `the organization being called: one minted against a different ` + `environment or audience is refused this way. Nothing was uploaded ` + `and nothing ran, so the ${subject} is not the cause.${bodySuffix}`;
+  }
+  const authenticated = `The session is authenticated — the token was issued and had not ` + `expired when the call went out — so re-running \`uip login\` mints ` + `the same token and fails the same way. `;
+  const diagnosis = challenge.error === "insufficient_scope" ? `Studio Web reported \`insufficient_scope\`${quoted}, so the ` + `token is valid and simply not allowed to do this: logging in ` + `again will not change it. ` : challenge.error ? `${authenticated}Studio Web gave the reason ` + `\`${challenge.error}\`${quoted}. ` : authenticated;
+  const closing = bodySuffix ? `If the grants and the tenant are already right, report the platform ` + `response, including its traceId.${bodySuffix}` : challenge.error ? `If the grants and the tenant are already right, report that reason ` + `together with the request path and status above.` : `If the grants and the tenant are already right, report the request ` + `path and status above — Studio Web returned no response body and ` + `no authentication challenge, so there is nothing further to quote.`;
+  return `Studio Web ${refusal} while ${what}. ${diagnosis}${actor}${tenant}` + `Nothing was uploaded and nothing ran, so the ${subject} is not the ` + `cause. ${closing}`;
+}
+function buildSolutionUploadFailureOutput(err, options = {}) {
+  const stage = err.operation === "overwrite" ? "overwrite-solution" : "import-solution";
+  const authRefusal = isAuthRefusal(err.status);
+  const parsedMessage = authRefusal && err.parsedErrorMessage ? redactTokens(err.parsedErrorMessage) : err.parsedErrorMessage;
+  const detail = parsedMessage ? ` — ${parsedMessage}` : "";
+  const Message = `Failed during ${stage}: HTTP ${err.status} on ${err.method} ` + `${err.endpoint}${detail}`;
+  const quote = authRefusal ? summarizeAuthRefusalBody : summarizePlatformBody;
+  const body = err.parsedErrorMessage ? "" : quote(err.body);
+  const bodySuffix = body ? ` Platform response: "${body}".` : "";
+  const importHint = options.importCheckHint ? ` ${options.importCheckHint}` : "";
+  const subject = options.subject ?? "project";
+  const target = err.solutionId ?? `the solution at ${err.endpoint}`;
+  const authInstructions = isAuthRefusal(err.status) ? buildAuthRefusalInstructions({
+    err,
+    subject,
+    target,
+    bodySuffix,
+    identityType: options.identityType,
+    clientId: options.clientId
+  }) : undefined;
+  const Instructions = authInstructions ?? (err.operation === "overwrite" ? `Studio Web refused to replace the contents of solution ` + `${target}. Nothing was uploaded and nothing ran, so the ` + `${subject} is not the cause: do not re-author it, and do not ` + `copy the project into another solution. Confirm that ${target} ` + `is a solution you can still write to, and that it is the one ` + `this project should publish to — it comes from the SolutionId ` + `recorded in the enclosing solution file. If it is right, report ` + `the platform response.${bodySuffix}` : `Studio Web refused to import the solution package. Nothing was ` + `uploaded and nothing ran, so no part of the ${subject} executed ` + `— but the package itself may be what was rejected.${importHint} ` + `Report the platform response if the ${subject} is ` + `well-formed.${bodySuffix}`);
+  const Context = {
+    httpStatus: err.status,
+    stage,
+    endpoint: err.endpoint,
+    method: err.method
+  };
+  if (err.parsedErrorCode !== undefined) {
+    Context.errorCode = err.parsedErrorCode;
+  }
+  const output = {
+    Result: RESULTS.Failure,
+    Message,
+    Instructions,
+    Context
+  };
+  if (err.status === 401 && options.identityType === "Application") {
+    output.ErrorCode = "permission_denied";
+  }
+  if (err.operation === "overwrite" && err.status >= 500 && err.status < 600) {
+    output.Retry = "RetryAfter30Seconds";
+  }
+  return output;
+}
+var DEFAULT_UPLOAD_TIMEOUT_MS = 120000;
+function resolveUploadTimeoutMs() {
+  const raw = Number(process.env?.UIPATH_SOLUTION_UPLOAD_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_UPLOAD_TIMEOUT_MS;
+}
+function formatTimeout(timeoutMs) {
+  return timeoutMs < 1000 ? `${Math.round(timeoutMs)}ms` : `${Math.round(timeoutMs / 1000)}s`;
+}
+function timeoutMessage(what, timeoutMs) {
+  return `${what} timed out after ${formatTimeout(timeoutMs)} — the connection ` + `stalled with no response from Studio Web. Retry the command; if it keeps ` + `timing out, check connectivity (VPN/proxy) to the tenant, or raise the ` + `ceiling with UIPATH_SOLUTION_UPLOAD_TIMEOUT_MS.`;
+}
+function isTimeoutError(error) {
+  let current = error;
+  for (let depth = 0;depth < 5 && current instanceof Error; depth += 1) {
+    if (current.name === "TimeoutError")
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+async function fetchWithUploadTimeout(url, init, what) {
+  const timeoutMs = resolveUploadTimeoutMs();
+  const [error, response] = await catchError(fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+  if (error) {
+    if (isTimeoutError(error)) {
+      throw new Error(timeoutMessage(what, timeoutMs));
+    }
+    throw error;
+  }
+  return response;
+}
+async function importSolution(config, organizationName, fileBuffer, fileName) {
+  const importUrl = `${config.baseUrl}/${encodeURIComponent(organizationName)}/studio_/backend/api/Solution/Import?desktopJit=true&useFileRest=true&enableUnifiedBuild=true`;
+  const formData = new FormData;
+  const fileBlob = new Blob([fileBuffer], {
+    type: "application/octet-stream"
+  });
+  formData.append("uploadFile", fileBlob, fileName);
+  formData.append("telemetryData", JSON.stringify({ FirstRun: false }));
+  const headers = addSdkUserAgentHeader({
+    Authorization: `Bearer ${config.authToken}`
+  }, SDK_USER_AGENT);
+  if (config.tenantId) {
+    headers["x-uipath-tenantid"] = config.tenantId;
+  }
+  const response = await fetchWithUploadTimeout(importUrl, { method: "POST", headers, body: formData }, "Studio Web solution import");
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new SolutionUploadHttpError({
+      operation: "import",
+      status: response.status,
+      method: "POST",
+      endpoint: requestPath(importUrl),
+      url: importUrl,
+      body: text,
+      authChallenge: response.headers?.get("www-authenticate") ?? undefined,
+      message: `Import failed (${response.status}): ${text}`
+    });
+  }
+  return await response.json();
+}
+async function overwriteSolution(config, organizationName, fileBuffer, fileName, solutionId, createSnapshot = false) {
+  const overwriteUrl = `${config.baseUrl}/${encodeURIComponent(organizationName)}/studio_/backend/api/Solution/${encodeURIComponent(solutionId)}/Overwrite`;
+  const formData = new FormData;
+  const fileBlob = new Blob([fileBuffer], {
+    type: "application/octet-stream"
+  });
+  formData.append("UploadFile", fileBlob, fileName);
+  if (createSnapshot) {
+    formData.append("createSnapshot", "true");
+  }
+  const headers = addSdkUserAgentHeader({
+    Authorization: `Bearer ${config.authToken}`
+  }, SDK_USER_AGENT);
+  if (config.tenantId) {
+    headers["x-uipath-tenantid"] = config.tenantId;
+  }
+  const response = await fetchWithUploadTimeout(overwriteUrl, { method: "POST", headers, body: formData }, "Studio Web solution overwrite");
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new SolutionUploadHttpError({
+      operation: "overwrite",
+      status: response.status,
+      method: "POST",
+      endpoint: requestPath(overwriteUrl),
+      url: overwriteUrl,
+      body: text,
+      authChallenge: response.headers?.get("www-authenticate") ?? undefined,
+      message: `Overwrite failed (${response.status}): ${text}`,
+      solutionId
+    });
+  }
+  return await response.json();
+}
+async function uploadOrOverwriteSolution(config, organizationName, fileBufferOrPath, solutionId, fs) {
+  let fileBuffer;
+  let fileName;
+  if (typeof fileBufferOrPath === "string") {
+    if (!fs) {
+      throw new Error("IFileSystem is required when passing a file path to uploadOrOverwriteSolution");
+    }
+    const content = await fs.readFile(fileBufferOrPath);
+    if (content === null) {
+      throw new Error(`Failed to read file: ${fileBufferOrPath}`);
+    }
+    fileBuffer = new Uint8Array(content);
+    fileName = fs.path.basename(fileBufferOrPath);
+  } else {
+    fileBuffer = fileBufferOrPath;
+    fileName = "solution.uis";
+  }
+  if (solutionId) {
+    logger.info(`Attempting to overwrite existing solution ${solutionId} on Studio Web...`);
+    const [overwriteError, overwriteResult] = await catchError(overwriteSolution(config, organizationName, fileBuffer, fileName, solutionId));
+    if (!overwriteError) {
+      logger.info("Solution overwritten successfully.");
+      return overwriteResult;
+    }
+    if (isSolutionUploadHttpError(overwriteError) && overwriteError.status === 404) {
+      logger.info(`Solution ${solutionId} not found on Studio Web. Importing as new solution...`);
+    } else {
+      throw overwriteError;
+    }
+  }
+  logger.info("Importing new solution to Studio Web...");
+  return importSolution(config, organizationName, fileBuffer, fileName);
+}
+// ../solution-sdk/src/zip-utils.ts
+var DEFAULT_EXCLUDED_DIR_NAMES = new Set([
+  ".venv",
+  "node_modules",
+  "__pycache__",
+  ".git",
+  ".local"
+]);
+var DEFAULT_EXCLUDED_FILE_PATTERNS = [
+  /^\.env($|\..+)/
+];
+function isDefaultExcludedFileName(name) {
+  for (const pattern of DEFAULT_EXCLUDED_FILE_PATTERNS) {
+    if (pattern.test(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+var UIPIGNORE_FILENAME = ".uipignore";
+function parseUipignore(body) {
+  const names = new Set;
+  for (const rawLine of body.split(/\r?\n/)) {
+    const line = rawLine.split("#")[0]?.trim();
+    if (!line) {
+      continue;
+    }
+    if (line.includes("/") || line.includes("\\")) {
+      continue;
+    }
+    names.add(line);
+  }
+  return names;
+}
+async function collectTree(fs, dir, options = {}) {
+  const files = [];
+  const emptyDirs = [];
+  const excluded = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
+  if (options.additionalExcludeDirs) {
+    for (const name of options.additionalExcludeDirs) {
+      excluded.add(name);
+    }
+  }
+  async function walk(current, isRoot) {
+    const entries = await fs.readdir(current);
+    if (entries.length === 0) {
+      if (!isRoot) {
+        emptyDirs.push(current);
+      }
+      return;
+    }
+    for (const entryName of entries) {
+      const fullPath = fs.path.join(current, entryName);
+      const entryStat = await fs.stat(fullPath);
+      if (entryStat?.isDirectory()) {
+        if (excluded.has(entryName)) {
+          continue;
+        }
+        await walk(fullPath, false);
+      } else if (entryStat?.isFile()) {
+        if (isDefaultExcludedFileName(entryName)) {
+          continue;
+        }
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(dir, true);
+  return { files, emptyDirs };
+}
+async function createZipFromDir(fs, dir, options = {}) {
+  const { files, emptyDirs } = await collectTree(fs, dir, options);
+  const zippable = {};
+  for (const filePath of files) {
+    const relPath = fs.path.relative(dir, filePath).replace(/\\/g, "/");
+    const data = await fs.readFile(filePath);
+    if (data) {
+      zippable[relPath] = new Uint8Array(data);
+    }
+  }
+  for (const emptyDir of emptyDirs) {
+    const relPath = fs.path.relative(dir, emptyDir).replace(/\\/g, "/");
+    if (!relPath) {
+      continue;
+    }
+    zippable[`${relPath}/`] = new Uint8Array(0);
+  }
+  return finalizeZip64(zipSync(zippable, { level: 6 }));
+}
+var EOCD_SIZE = 22;
+var EOCD_SIGNATURE = 101010256;
+var CD_HEADER_SIGNATURE = 33639248;
+var ZIP64_EOCD_SIGNATURE = 101075792;
+var ZIP64_EOCD_SIZE = 56;
+var ZIP64_LOCATOR_SIGNATURE = 117853008;
+var ZIP64_LOCATOR_SIZE = 20;
+var MAX_ZIP32_ENTRIES = 65535;
+var MAX_ZIP32_OFFSET = 4294967295;
+function finalizeZip64(zip) {
+  const view = new DataView(zip.buffer, zip.byteOffset, zip.byteLength);
+  const eocdStart = zip.byteLength - EOCD_SIZE;
+  if (eocdStart < 0 || view.getUint32(eocdStart, true) !== EOCD_SIGNATURE) {
+    throw new Error("Cannot finalize the solution archive: it does not end with an end-of-central-directory record.");
+  }
+  const cdSize = view.getUint32(eocdStart + 12, true);
+  const cdOffset = view.getUint32(eocdStart + 16, true);
+  const entryCount = countCentralDirectoryEntries(view, cdOffset, cdSize);
+  if (entryCount <= MAX_ZIP32_ENTRIES) {
+    return zip;
+  }
+  if (cdOffset >= MAX_ZIP32_OFFSET || zip.byteLength >= MAX_ZIP32_OFFSET) {
+    throw new Error(`The solution archive is ${zip.byteLength} bytes, past the 4 GB limit this packer supports. Exclude large directories from the solution with a .uipignore file.`);
+  }
+  const tail = new Uint8Array(ZIP64_EOCD_SIZE + ZIP64_LOCATOR_SIZE + EOCD_SIZE);
+  const tailView = new DataView(tail.buffer);
+  const count = BigInt(entryCount);
+  tailView.setUint32(0, ZIP64_EOCD_SIGNATURE, true);
+  tailView.setBigUint64(4, BigInt(ZIP64_EOCD_SIZE - 12), true);
+  tailView.setUint16(12, 45, true);
+  tailView.setUint16(14, 45, true);
+  tailView.setUint32(16, 0, true);
+  tailView.setUint32(20, 0, true);
+  tailView.setBigUint64(24, count, true);
+  tailView.setBigUint64(32, count, true);
+  tailView.setBigUint64(40, BigInt(cdSize), true);
+  tailView.setBigUint64(48, BigInt(cdOffset), true);
+  const locator = ZIP64_EOCD_SIZE;
+  tailView.setUint32(locator, ZIP64_LOCATOR_SIGNATURE, true);
+  tailView.setUint32(locator + 4, 0, true);
+  tailView.setBigUint64(locator + 8, BigInt(eocdStart), true);
+  tailView.setUint32(locator + 16, 1, true);
+  const eocd = ZIP64_EOCD_SIZE + ZIP64_LOCATOR_SIZE;
+  tailView.setUint32(eocd, EOCD_SIGNATURE, true);
+  tailView.setUint16(eocd + 4, 0, true);
+  tailView.setUint16(eocd + 6, 0, true);
+  tailView.setUint16(eocd + 8, MAX_ZIP32_ENTRIES, true);
+  tailView.setUint16(eocd + 10, MAX_ZIP32_ENTRIES, true);
+  tailView.setUint32(eocd + 12, cdSize, true);
+  tailView.setUint32(eocd + 16, cdOffset, true);
+  tailView.setUint16(eocd + 20, 0, true);
+  const out = new Uint8Array(eocdStart + tail.byteLength);
+  out.set(zip.subarray(0, eocdStart), 0);
+  out.set(tail, eocdStart);
+  return out;
+}
+function countCentralDirectoryEntries(view, cdOffset, cdSize) {
+  const end = cdOffset + cdSize;
+  let position = cdOffset;
+  let count = 0;
+  while (position + 46 <= end && view.getUint32(position, true) === CD_HEADER_SIGNATURE) {
+    const nameLength = view.getUint16(position + 28, true);
+    const extraLength = view.getUint16(position + 30, true);
+    const commentLength = view.getUint16(position + 32, true);
+    position += 46 + nameLength + extraLength + commentLength;
+    count++;
+  }
+  return count;
+}
+
+// ../solution-sdk/src/bundle-service.ts
+async function readUipignore(fs, dir) {
+  const ignorePath = fs.path.join(dir, UIPIGNORE_FILENAME);
+  if (!await fs.exists(ignorePath)) {
+    return new Set;
+  }
+  try {
+    const body = await fs.readFile(ignorePath, "utf-8");
+    if (!body) {
+      return new Set;
+    }
+    return parseUipignore(body);
+  } catch (err) {
+    logger.warn(`Could not read ${UIPIGNORE_FILENAME}; ignoring it: ${String(err)}`);
+    return new Set;
+  }
+}
+async function mergeProjectUipignore(fs, projectPath, projectLabel, solutionExcludeDirs) {
+  const projectExtra = await readUipignore(fs, projectPath);
+  if (projectExtra.size === 0) {
+    return solutionExcludeDirs;
+  }
+  const merged = new Set(solutionExcludeDirs);
+  for (const name of projectExtra) {
+    merged.add(name);
+  }
+  logger.info(`[${projectLabel}] Applying ${projectExtra.size} extra exclude(s) from project ${UIPIGNORE_FILENAME}: ${[...projectExtra].join(", ")}`);
+  return merged;
+}
+var toForwardSlash = (p) => p.replace(/\\/g, "/");
+async function mirrorTree(fs, srcDir, relativeBase, destBaseDir, additionalExcludeDirs) {
+  const { files, emptyDirs } = await collectTree(fs, srcDir, {
+    additionalExcludeDirs
+  });
+  if (files.length === 0 && emptyDirs.length === 0) {
+    const rootRel = fs.path.relative(relativeBase, srcDir);
+    if (rootRel) {
+      await fs.mkdir(fs.path.join(destBaseDir, rootRel));
+    }
+    return;
+  }
+  for (const f of files) {
+    const relPath = fs.path.relative(relativeBase, f);
+    const destPath = fs.path.join(destBaseDir, relPath);
+    const data = await fs.readFile(f);
+    if (data) {
+      await fs.writeFile(destPath, data);
+    } else {
+      logger.warn(`Skipping empty or unreadable file: ${f}`);
+    }
+  }
+  for (const dir of emptyDirs) {
+    const relPath = fs.path.relative(relativeBase, dir);
+    if (!relPath) {
+      continue;
+    }
+    await fs.mkdir(fs.path.join(destBaseDir, relPath));
+  }
+}
+async function flattenProjectDir(fs, srcProjectDir, destProjectDir, additionalExcludeDirs) {
+  await fs.mkdir(destProjectDir);
+  const topLevelExclude = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
+  if (additionalExcludeDirs) {
+    for (const name of additionalExcludeDirs) {
+      topLevelExclude.add(name);
+    }
+  }
+  const entries = await fs.readdir(srcProjectDir);
+  for (const entryName of entries) {
+    const srcPath = fs.path.join(srcProjectDir, entryName);
+    const entryStat = await fs.stat(srcPath);
+    if (!entryStat) {
+      continue;
+    }
+    if (entryStat.isFile()) {
+      if (isDefaultExcludedFileName(entryName)) {
+        continue;
+      }
+      const data = await fs.readFile(srcPath);
+      if (data) {
+        await fs.writeFile(fs.path.join(destProjectDir, entryName), data);
+      }
+    } else if (entryStat.isDirectory()) {
+      if (topLevelExclude.has(entryName)) {
+        continue;
+      }
+      if (entryName === "content" || entryName === "flow_files") {
+        await mirrorTree(fs, srcPath, srcPath, destProjectDir, additionalExcludeDirs);
+      } else {
+        await mirrorTree(fs, srcPath, srcProjectDir, destProjectDir, additionalExcludeDirs);
+      }
+    }
+  }
+}
+async function bundleSolution(fs, solutionDir, outputDir, outputName) {
+  const resolvedPath = fs.path.resolve(solutionDir);
+  const solStat = await fs.stat(resolvedPath);
+  if (!solStat) {
+    throw new Error(`Path not found: ${resolvedPath}`);
+  }
+  if (!solStat.isDirectory()) {
+    throw new Error(`Not a directory: ${resolvedPath}. Provide the solution directory containing a .uipx file.`);
+  }
+  const { uipx, uipxFileName } = await readUipxFile(fs, resolvedPath);
+  const additionalExcludeDirs = await readUipignore(fs, resolvedPath);
+  if (additionalExcludeDirs.size > 0) {
+    logger.info(`Applying ${additionalExcludeDirs.size} extra exclude(s) from .uipignore: ${[...additionalExcludeDirs].join(", ")}`);
+  }
+  const effectiveExclude = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
+  for (const name of additionalExcludeDirs) {
+    effectiveExclude.add(name);
+  }
+  for (const project of uipx.Projects) {
+    project.ProjectRelativePath = toForwardSlash(project.ProjectRelativePath);
+  }
+  assertStudioWebCompatibleProjects(uipx.Projects);
+  const solutionStorage = {
+    SolutionId: uipx.SolutionId,
+    Projects: uipx.Projects.map((p) => ({
+      ProjectId: p.Id,
+      ProjectRelativePath: p.ProjectRelativePath
+    }))
+  };
+  const solutionName = outputName || fs.path.basename(uipxFileName, ".uipx");
+  const stagingDir = fs.path.join(resolvedPath, `.uis-staging-${Date.now()}`);
+  await fs.mkdir(stagingDir);
+  try {
+    await fs.writeFile(fs.path.join(stagingDir, "SolutionStorage.json"), JSON.stringify(solutionStorage));
+    await fs.writeFile(fs.path.join(stagingDir, uipxFileName), JSON.stringify(uipx));
+    for (const project of uipx.Projects) {
+      const projectDir = fs.path.dirname(project.ProjectRelativePath);
+      const srcProjectPath = fs.path.join(resolvedPath, projectDir);
+      const projectStat = await fs.stat(srcProjectPath);
+      if (!projectStat) {
+        throw new Error(`Project directory not found: ${srcProjectPath}`);
+      }
+      const projectExcludeDirs = await mergeProjectUipignore(fs, srcProjectPath, projectDir, additionalExcludeDirs);
+      await flattenProjectDir(fs, srcProjectPath, fs.path.join(stagingDir, projectDir), projectExcludeDirs);
+    }
+    const resourcesPath = fs.path.join(resolvedPath, "resources");
+    if (!effectiveExclude.has("resources") && await fs.exists(resourcesPath)) {
+      await mirrorTree(fs, resourcesPath, resolvedPath, stagingDir, additionalExcludeDirs);
+    }
+    const userProfilePath = fs.path.join(resolvedPath, "userProfile");
+    if (!effectiveExclude.has("userProfile") && await fs.exists(userProfilePath)) {
+      await mirrorTree(fs, userProfilePath, resolvedPath, stagingDir, additionalExcludeDirs);
+    }
+    const resolvedOutputDir = fs.path.resolve(outputDir);
+    if (!await fs.exists(resolvedOutputDir)) {
+      await fs.mkdir(resolvedOutputDir);
+    }
+    const uisPath = fs.path.join(resolvedOutputDir, `${solutionName}.uis`);
+    const zipData = await createZipFromDir(fs, stagingDir);
+    await fs.writeFile(uisPath, zipData);
+    const uipxPath = fs.path.join(resolvedPath, uipxFileName);
+    return {
+      uisPath,
+      solutionName,
+      solutionId: uipx.SolutionId,
+      uipxPath,
+      projects: uipx.Projects.map((p) => ({
+        Name: fs.path.dirname(p.ProjectRelativePath),
+        Type: p.Type
+      }))
+    };
+  } finally {
+    await fs.rm(stagingDir);
+  }
+}
+// ../solution-sdk/src/project-debug-status.ts
+var SUCCEEDED = "creationsucceeded";
+var TERMINAL = new Set([SUCCEEDED, "creationfailed", "validationfailed"]);
+// src/services/agent-debug-service.ts
+import { randomUUID } from "node:crypto";
+
+// src/services/agent-builder-migrations.ts
+var warnedLegacyToolGuardrailPolicies = false;
+function migrateLegacyToolGuardrailPolicies(builder) {
+  let migrated = false;
+  for (const resource of builder.resources ?? []) {
+    if (resource.$resourceType !== "tool" || !Array.isArray(resource.guardrailPolicies)) {
+      continue;
+    }
+    if (!resource.guardrail?.policies?.length) {
+      resource.guardrail = { policies: resource.guardrailPolicies };
+      migrated = true;
+    }
+    delete resource.guardrailPolicies;
+  }
+  if (migrated && !warnedLegacyToolGuardrailPolicies) {
+    OutputFormatter.log({
+      Warning: "Migrated legacy guardrailPolicies to guardrail.policies."
+    });
+    warnedLegacyToolGuardrailPolicies = true;
+  }
+}
+
+// src/services/agent-project-service.ts
+class AgentProjectService {
+  fs = getFileSystem();
+  resolvedAgentDirs = new Map;
+  getAgentDir(projectPath) {
+    const cached = this.resolvedAgentDirs.get(projectPath);
+    if (cached) {
+      return cached;
+    }
+    return projectPath;
+  }
+  async resolveAgentDir(projectPath) {
+    const cached = this.resolvedAgentDirs.get(projectPath);
+    if (cached) {
+      return cached;
+    }
+    const flatAgent = this.fs.path.join(projectPath, "agent.json");
+    if (await this.fs.stat(flatAgent)) {
+      this.resolvedAgentDirs.set(projectPath, projectPath);
+      return projectPath;
+    }
+    const entries = await this.fs.readdir(projectPath);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "evals" || entry === "features" || entry === "resources" || entry === "userProfile") {
+        continue;
+      }
+      const candidate = this.fs.path.join(projectPath, entry);
+      const candidateStat = await this.fs.stat(candidate);
+      if (!candidateStat?.isDirectory())
+        continue;
+      const agentStat = await this.fs.stat(this.fs.path.join(candidate, "agent.json"));
+      if (agentStat) {
+        this.resolvedAgentDirs.set(projectPath, candidate);
+        return candidate;
+      }
+    }
+    this.resolvedAgentDirs.set(projectPath, projectPath);
+    return projectPath;
+  }
+  async readAgentJson(projectPath) {
+    const agentDir = this.getAgentDir(projectPath);
+    const raw = await this.fs.readFile(this.fs.path.join(agentDir, "agent.json"), "utf-8");
+    return JSON.parse(raw);
+  }
+  async writeAgentJson(projectPath, agent) {
+    const agentDir = this.getAgentDir(projectPath);
+    await this.fs.writeFile(this.fs.path.join(agentDir, "agent.json"), `${JSON.stringify(agent, null, 2)}
+`);
+    const builderDir = this.fs.path.join(agentDir, ".agent-builder");
+    await this.safeMkdir(builderDir);
+    let existingBuilder;
+    const [builderReadError, builderRaw] = await catchError(this.fs.readFile(this.fs.path.join(builderDir, "agent.json"), "utf-8"));
+    if (!builderReadError && builderRaw) {
+      try {
+        existingBuilder = JSON.parse(builderRaw);
+        migrateLegacyToolGuardrailPolicies(existingBuilder);
+      } catch {}
+    }
+    const builderAgent = {
+      id: agent.projectId,
+      name: existingBuilder?.name ?? "Agent",
+      ...agent,
+      resources: existingBuilder?.resources ?? agent.resources ?? [],
+      features: existingBuilder?.features ?? agent.features ?? []
+    };
+    await this.fs.writeFile(this.fs.path.join(builderDir, "agent.json"), `${JSON.stringify(builderAgent, null, 2)}
+`);
+  }
+  async readSolutionStorage(projectPath) {
+    const raw = await this.fs.readFile(this.fs.path.join(projectPath, "SolutionStorage.json"), "utf-8");
+    return JSON.parse(raw);
+  }
+  async writeSolutionStorage(projectPath, storage) {
+    await this.fs.writeFile(this.fs.path.join(projectPath, "SolutionStorage.json"), `${JSON.stringify(storage, null, 2)}
+`);
+  }
+  async readEvaluator(projectPath, fileName) {
+    const filePath = this.fs.path.join(this.getAgentDir(projectPath), "evals", "evaluators", fileName);
+    const raw = await this.fs.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  }
+  async writeEvaluator(projectPath, evaluator) {
+    const dir = this.fs.path.join(this.getAgentDir(projectPath), "evals", "evaluators");
+    await this.safeMkdir(dir);
+    await this.fs.writeFile(this.fs.path.join(dir, evaluator.fileName), `${JSON.stringify(evaluator, null, 2)}
+`);
+  }
+  async listEvaluators(projectPath) {
+    const dir = this.fs.path.join(this.getAgentDir(projectPath), "evals", "evaluators");
+    const [error, files] = await catchError(this.fs.readdir(dir));
+    if (error) {
+      return [];
+    }
+    const evaluators = [];
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        const raw = await this.fs.readFile(this.fs.path.join(dir, file), "utf-8");
+        evaluators.push(JSON.parse(raw));
+      }
+    }
+    return evaluators;
+  }
+  async deleteEvaluator(projectPath, fileName) {
+    const filePath = this.fs.path.join(this.getAgentDir(projectPath), "evals", "evaluators", fileName);
+    await this.fs.rm(filePath);
+  }
+  async readEvalSet(projectPath, fileName) {
+    const filePath = this.fs.path.join(this.getAgentDir(projectPath), "evals", "eval-sets", fileName);
+    const raw = await this.fs.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  }
+  async writeEvalSet(projectPath, evalSet, fileName) {
+    const dir = this.fs.path.join(this.getAgentDir(projectPath), "evals", "eval-sets");
+    await this.safeMkdir(dir);
+    await this.fs.writeFile(this.fs.path.join(dir, fileName), `${JSON.stringify(evalSet, null, 2)}
+`);
+  }
+  async listEvalSets(projectPath) {
+    const dir = this.fs.path.join(this.getAgentDir(projectPath), "evals", "eval-sets");
+    const [error, files] = await catchError(this.fs.readdir(dir));
+    if (error) {
+      return [];
+    }
+    const sets = [];
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        const raw = await this.fs.readFile(this.fs.path.join(dir, file), "utf-8");
+        sets.push(JSON.parse(raw));
+      }
+    }
+    return sets;
+  }
+  async deleteEvalSet(projectPath, fileName) {
+    const filePath = this.fs.path.join(this.getAgentDir(projectPath), "evals", "eval-sets", fileName);
+    await this.fs.rm(filePath);
+  }
+  async writeFeature(projectPath, featureName, feature) {
+    this.validateFeatureName(featureName);
+    const dir = this.fs.path.join(this.getAgentDir(projectPath), "features", featureName);
+    await this.safeMkdir(dir);
+    await this.fs.writeFile(this.fs.path.join(dir, "feature.json"), `${JSON.stringify(feature, null, 2)}
+`);
+  }
+  async readFeature(projectPath, featureName) {
+    this.validateFeatureName(featureName);
+    const filePath = this.fs.path.join(this.getAgentDir(projectPath), "features", featureName, "feature.json");
+    const raw = await this.fs.readFile(filePath, "utf-8");
+    if (!raw) {
+      throw new Error(`Feature file not found: ${filePath}`);
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed) {
+      throw new Error(`Feature file is empty: ${filePath}`);
+    }
+    return parsed;
+  }
+  async listFeatureDirs(projectPath) {
+    const dir = this.fs.path.join(this.getAgentDir(projectPath), "features");
+    const [error, entries] = await catchError(this.fs.readdir(dir));
+    if (error) {
+      return [];
+    }
+    return entries;
+  }
+  async deleteFeature(projectPath, featureName) {
+    this.validateFeatureName(featureName);
+    const dir = this.fs.path.join(this.getAgentDir(projectPath), "features", featureName);
+    await this.fs.rm(dir);
+  }
+  async safeMkdir(dir) {
+    await this.fs.mkdir(dir);
+  }
+  async writeJsonFile(filePath, data) {
+    await this.fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`);
+  }
+  validateFeatureName(featureName) {
+    if (featureName.trim().length === 0 || featureName === "." || featureName === ".." || featureName.includes("/") || featureName.includes("\\") || featureName.includes("\x00") || featureName !== this.fs.path.basename(featureName)) {
+      throw new Error(`Invalid feature name: "${featureName}"`);
+    }
+  }
+}
+
+// src/services/pack-helpers.ts
+async function collectProjectFiles(rootDir) {
+  const files = [];
+  await collectRecursive(rootDir, rootDir, files);
+  return files;
+}
+async function collectRecursive(rootDir, currentDir, files) {
+  const fs = getFileSystem();
+  const entries = await fs.readdir(currentDir);
+  for (const entry of entries) {
+    const fullPath = fs.path.join(currentDir, entry);
+    const stats = await fs.stat(fullPath);
+    if (stats?.isDirectory()) {
+      await collectRecursive(rootDir, fullPath, files);
+    } else if (stats) {
+      files.push(fs.path.relative(rootDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+}
+function matchesExclude(relPath, exclude) {
+  for (const pattern of exclude) {
+    const cleaned = pattern.replace(/^\.\//, "").replace(/\/\*$/, "");
+    if (cleaned.startsWith("*")) {
+      const suffix = cleaned.slice(1).replace(/^\//, "");
+      if (relPath.includes(`/${suffix}/`) || relPath.includes(`/${suffix}`)) {
+        return true;
+      }
+    }
+    if (relPath === cleaned || relPath.startsWith(`${cleaned}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function createArchive(sourceDir, outputPath, exclude) {
+  const fs = getFileSystem();
+  const files = await collectProjectFiles(sourceDir);
+  const zippable = {};
+  for (const relPath of files) {
+    if (exclude && matchesExclude(relPath, exclude)) {
+      continue;
+    }
+    const data = await fs.readFile(fs.path.join(sourceDir, relPath));
+    if (data !== null) {
+      zippable[relPath] = new Uint8Array(data);
+    }
+  }
+  await fs.writeFile(outputPath, finalizeZip64(zipSync(zippable, { level: 6 })));
+}
+
+// src/services/agent-local-workspace-eval-preparer.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+  return UUID_PATTERN.test(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toForwardSlash2(path) {
+  return path.replace(/\\/g, "/");
+}
+async function resolveStudioWebConfig() {
+  const [loginError, login] = await catchError(getLoginStatusAsync());
+  if (loginError) {
+    throw new Error(loginError.message);
+  }
+  if (login.loginStatus !== "Logged in" || !login.baseUrl) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  if (!login.accessToken) {
+    throw new Error("Access token not available from login.");
+  }
+  if (!login.organizationName) {
+    throw new Error("Organization name not available from login. Required for Studio Web evaluation.");
+  }
+  return {
+    baseUrl: login.baseUrl,
+    tenantId: login.tenantId,
+    authToken: login.accessToken,
+    organizationName: login.organizationName
+  };
+}
+
+class AgentLocalWorkspaceEvalPreparer {
+  fs;
+  constructor(fs = getFileSystem()) {
+    this.fs = fs;
+  }
+  async isLocalWorkspace(projectPath) {
+    return await this.readLocalWorkspaceMarker(projectPath) !== undefined;
+  }
+  async prepare(projectPath, config, existingSolutionIdOverride) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const marker = await this.readLocalWorkspaceMarker(absoluteProjectPath);
+    const packageRoot = marker?.rootPath ?? absoluteProjectPath;
+    const projectService = new AgentProjectService;
+    const agentDir = await projectService.resolveAgentDir(absoluteProjectPath);
+    const agent = await projectService.readAgentJson(absoluteProjectPath);
+    const projectFilePath = this.fs.path.join(agentDir, "project.uiproj");
+    if (!await this.fs.exists(projectFilePath)) {
+      throw new Error(`Not a valid agent project directory: missing project.uiproj in ${agentDir}`);
+    }
+    const projectFileContent = await this.fs.readFile(projectFilePath, "utf-8");
+    const [projectFileError, parsedProjectFile] = catchError(() => JSON.parse(String(projectFileContent)));
+    if (projectFileError || !isRecord(parsedProjectFile)) {
+      throw new Error(`Invalid project.uiproj in ${agentDir}: ${projectFileError?.message ?? "expected a JSON object"}`);
+    }
+    const projectFile = {
+      Name: typeof parsedProjectFile.Name === "string" ? parsedProjectFile.Name : undefined
+    };
+    const solutionInfo = await findSolutionFile(this.fs, agentDir);
+    const solutionId = existingSolutionIdOverride ?? marker?.solutionId ?? solutionInfo?.solutionId;
+    const solutionName = projectFile.Name ?? agent.metadata.name ?? this.fs.path.basename(agentDir);
+    const safeSolutionName = solutionName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const stagingDir = this.fs.path.join(this.fs.env.tmpdir(), `.agent-eval-staging-${safeSolutionName}-${Date.now()}`);
+    await this.fs.mkdir(stagingDir);
+    const uisPath = this.fs.path.join(stagingDir, `${safeSolutionName}.uis`);
+    try {
+      logger.info("Building agent package for local workspace eval...");
+      await createArchive(packageRoot, uisPath, [
+        "./.agent-builder/*",
+        "*/.agent-builder/*",
+        ".sw-path-marker",
+        "*/.sw-path-marker"
+      ]);
+      logger.info("Uploading local workspace agent for eval...");
+      const importResult = await uploadOrOverwriteSolution({
+        baseUrl: config.baseUrl,
+        tenantId: config.tenantId,
+        authToken: config.authToken
+      }, config.organizationName, uisPath, solutionId, this.fs);
+      const matchedProject = this.resolveImportedProject(importResult, solutionName);
+      await this.persistSolutionStorage(projectService, absoluteProjectPath, packageRoot, projectFilePath, importResult.id, agent.projectId, matchedProject.id);
+      if (packageRoot !== absoluteProjectPath) {
+        await this.persistSolutionStorage(projectService, packageRoot, packageRoot, projectFilePath, importResult.id, agent.projectId, matchedProject.id);
+      }
+      await updateSolutionFile(this.fs, agentDir, importResult.id);
+      if (marker) {
+        await this.updateLocalWorkspaceMarker(marker.rootPath, importResult.id);
+      }
+      return {
+        solutionId: importResult.id,
+        agentProjectId: matchedProject.id
+      };
+    } finally {
+      const [cleanupError] = await catchError(this.fs.rm(stagingDir, { recursive: true }));
+      if (cleanupError) {
+        logger.warn(`Cleanup failed: ${cleanupError.message}`);
+      }
+    }
+  }
+  async readLocalWorkspaceMarker(projectPath) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const candidates = [
+      absoluteProjectPath,
+      this.fs.path.dirname(absoluteProjectPath)
+    ];
+    for (const candidate of candidates) {
+      const markerPath = this.fs.path.join(candidate, ".sw-path-marker");
+      if (!await this.fs.exists(markerPath)) {
+        continue;
+      }
+      const content = String(await this.fs.readFile(markerPath, "utf-8"));
+      const solutionId = content.trim();
+      return {
+        rootPath: candidate,
+        ...isUUID(solutionId) ? { solutionId } : {}
+      };
+    }
+    return;
+  }
+  resolveImportedProject(importResult, agentName) {
+    const exactProject = importResult.projects.find((project) => project.name === agentName);
+    if (exactProject?.id) {
+      return exactProject;
+    }
+    const [onlyProject] = importResult.projects;
+    if (importResult.projects.length === 1 && onlyProject?.id) {
+      return onlyProject;
+    }
+    throw new Error(`Upload response had ${importResult.projects.length} projects and none matched "${agentName}"; refusing to guess.`);
+  }
+  async persistSolutionStorage(projectService, storagePath, packageRoot, projectFilePath, solutionId, localProjectId, cloudProjectId) {
+    const projectRelativePath = toForwardSlash2(this.fs.path.relative(packageRoot, projectFilePath));
+    const projectEntry = {
+      ProjectId: localProjectId,
+      ProjectRelativePath: projectRelativePath || "project.uiproj",
+      CloudProjectId: cloudProjectId
+    };
+    const [, existingStorage] = await catchError(projectService.readSolutionStorage(storagePath));
+    const existingProjects = existingStorage?.Projects ?? [];
+    const projectIndex = existingProjects.findIndex((project) => project.ProjectId === localProjectId);
+    const projects = projectIndex === -1 ? [...existingProjects, projectEntry] : existingProjects.map((project, index) => index === projectIndex ? { ...project, ...projectEntry } : project);
+    await projectService.writeSolutionStorage(storagePath, {
+      SolutionId: solutionId,
+      Projects: projects
+    });
+  }
+  async updateLocalWorkspaceMarker(workspaceRoot, solutionId) {
+    await this.fs.writeFile(this.fs.path.join(workspaceRoot, ".sw-path-marker"), solutionId);
+  }
+}
+
+// src/services/agent-debug-service.ts
+class AgentDebugCancelledError extends Error {
+  jobKey;
+  constructor(jobKey) {
+    super(jobKey ? `Debug run cancelled. Job ${jobKey} may still be running on the serverless runtime.` : "Debug run cancelled before the job started.");
+    this.name = "AgentDebugCancelledError";
+    this.jobKey = jobKey;
+  }
+}
+var TERMINAL_STATES = new Set([
+  "Successful",
+  "Faulted",
+  "Stopped",
+  "Suspended"
+]);
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class AgentDebugService {
+  fs = getFileSystem();
+  projectService = new AgentProjectService;
+  async debug(options, auth) {
+    throwIfAborted(options.signal);
+    const projectId = await this.resolveProjectId(options.projectPath);
+    throwIfAborted(options.signal);
+    const folderKey = await this.resolvePersonalWorkspaceKey();
+    throwIfAborted(options.signal);
+    const { jobKey, traceId } = await asCancellation(() => this.startDebugJob(auth, folderKey, projectId, options.inputs, options.signal));
+    const job = await asCancellation(() => this.pollJob(auth, folderKey, jobKey, options), jobKey);
+    return {
+      jobKey,
+      traceId,
+      finalState: job.state,
+      success: job.state === "Successful",
+      output: job.output,
+      info: job.info
+    };
+  }
+  async resolveProjectId(projectPath) {
+    const preparer = new AgentLocalWorkspaceEvalPreparer;
+    if (await preparer.isLocalWorkspace(projectPath)) {
+      const [, storage] = await catchError(this.projectService.readSolutionStorage(projectPath));
+      const config = await resolveStudioWebConfig();
+      const prepared = await preparer.prepare(projectPath, config, storage?.SolutionId);
+      return prepared.agentProjectId;
+    }
+    return this.uploadSolutionAndResolveProjectId(projectPath);
+  }
+  async uploadSolutionAndResolveProjectId(projectPath) {
+    const solution = await findSolutionFile(this.fs, projectPath);
+    if (!solution) {
+      throw new Error(`No enclosing .uipx solution found for '${projectPath}'. Create one with 'uip solution init' and add the agent to it.`);
+    }
+    const config = await resolveStudioWebConfig();
+    const solutionDir = this.fs.path.resolve(projectPath, "..");
+    const tempDir = await this.fs.getTempDir();
+    try {
+      const bundle = await bundleSolution(this.fs, solutionDir, tempDir);
+      const importResult = await uploadOrOverwriteSolution(config, config.organizationName, bundle.uisPath, bundle.solutionId, this.fs);
+      if (importResult.id && bundle.uipxPath) {
+        await updateUipxSolutionId(this.fs, bundle.uipxPath, importResult.id);
+      }
+      const projectName = await this.readProjectName(projectPath);
+      const byName = importResult.projects.find((p) => p.name === projectName);
+      if (byName?.id) {
+        return byName.id;
+      }
+      const [only] = importResult.projects;
+      if (importResult.projects.length === 1 && only?.id) {
+        return only.id;
+      }
+      throw new Error(`Could not resolve the Studio Web project for "${projectName}": the upload returned ${importResult.projects.length} projects and none is named "${projectName}". Ensure the Name in project.uiproj matches the agent project in the solution.`);
+    } finally {
+      const [cleanupError] = await catchError(this.fs.rm(tempDir));
+      if (cleanupError) {
+        logger.debug(`Failed to clean up temp dir: ${cleanupError.message}`);
+      }
+    }
+  }
+  async readProjectName(projectPath) {
+    const [, content] = await catchError(this.fs.readFile(this.fs.path.join(projectPath, "project.uiproj"), "utf-8"));
+    const [, parsed] = catchError(() => JSON.parse(String(content)));
+    return parsed?.Name ?? this.fs.path.basename(projectPath);
+  }
+  async resolvePersonalWorkspaceKey() {
+    const wsApi = await createApiClient(PersonalWorkspacesApi, {});
+    const workspace = await wsApi.personalWorkspacesGetPersonalWorkspace();
+    if (!workspace?.key) {
+      throw new Error("Could not resolve your personal workspace. Ensure it is enabled for your account.");
+    }
+    return workspace.key;
+  }
+  orchestratorBaseUrl(auth) {
+    return `${auth.baseUrl}/${auth.organizationId}/${auth.tenantName}/orchestrator_`;
+  }
+  async startDebugJob(auth, folderKey, projectId, inputs, signal) {
+    const traceId = randomUUID();
+    const inputArguments = JSON.stringify({
+      Command: "debug",
+      EntryPoint: "agent.json",
+      Input: JSON.stringify(inputs),
+      args: "--attach=none"
+    });
+    const response = await fetch(`${this.orchestratorBaseUrl(auth)}/api/serverless/jobs`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${auth.accessToken}`,
+        "Content-Type": "application/json",
+        "X-UIPATH-FolderKey": folderKey
+      },
+      body: JSON.stringify({
+        JobType: "PythonAgent",
+        InputArguments: inputArguments,
+        Source: "StudioWeb",
+        RunAsMe: true,
+        EnvironmentVariables: `UIPATH_PROJECT_ID=${projectId}`,
+        TraceId: traceId,
+        Reference: randomUUID()
+      }),
+      signal
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to start debug job: ${response.status} ${await response.text()}`);
+    }
+    const data = await response.json();
+    if (!data.key) {
+      throw new Error("Debug job started but no job key was returned.");
+    }
+    return { jobKey: data.key, traceId };
+  }
+  async pollJob(auth, folderKey, jobKey, options) {
+    const url = `${this.orchestratorBaseUrl(auth)}/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier=${jobKey})`;
+    const headers = {
+      Authorization: `Bearer ${auth.accessToken}`,
+      "X-UIPATH-FolderKey": folderKey
+    };
+    let lastState = "";
+    let consecutiveErrors = 0;
+    const maxConsecutiveErrors = 3;
+    for (let poll = 0;poll < options.maxPolls; poll++) {
+      await delay(options.pollIntervalMs);
+      throwIfAborted(options.signal, jobKey);
+      const response = await fetch(url, {
+        headers,
+        signal: options.signal
+      });
+      if (!response.ok) {
+        consecutiveErrors++;
+        if (response.status < 500 || consecutiveErrors > maxConsecutiveErrors) {
+          const body = await response.text();
+          throw new Error(`Failed to poll debug job (HTTP ${response.status}): ${body.slice(0, 300)}`);
+        }
+        continue;
+      }
+      consecutiveErrors = 0;
+      const job = await response.json();
+      if (job.State !== lastState) {
+        lastState = job.State;
+        options.onState?.(job.State);
+      }
+      if (TERMINAL_STATES.has(job.State)) {
+        return {
+          state: job.State,
+          output: parseOutput(job.OutputArguments),
+          info: job.Info?.trim() || undefined
+        };
+      }
+    }
+    throw new Error(`Debug run did not reach a terminal state within the timeout (last state: ${lastState || "unknown"}). Increase --timeout and retry.`);
+  }
+}
+function throwIfAborted(signal, jobKey) {
+  if (signal?.aborted) {
+    throw new AgentDebugCancelledError(jobKey);
+  }
+}
+async function asCancellation(step, jobKey) {
+  try {
+    return await step();
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw new AgentDebugCancelledError(jobKey);
+    }
+    throw error;
+  }
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+function parseOutput(outputArguments) {
+  if (!outputArguments) {
+    return;
+  }
+  const [error, parsed] = catchError(() => JSON.parse(outputArguments));
+  return error ? outputArguments : parsed;
+}
+
+export { StudioWebIncompatibleProjectError, isSolutionUploadHttpError, buildSolutionUploadFailureOutput, migrateLegacyToolGuardrailPolicies, AgentProjectService, resolveStudioWebConfig, AgentLocalWorkspaceEvalPreparer, AgentDebugCancelledError, AgentDebugService };
+
+//# debugId=936AF142F4482B6164756E2164756E21