@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/governance-fetcher-j9cx4f1d.js

@@ -0,0 +1,391 @@
+import {
+  getAuthContext
+} from "./packager-tool-f0kd5kq4.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yc4kw997.js";
+import {
+  addSdkUserAgentHeader,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader,
+  logger
+} from "./packager-tool-5qaxht3k.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../agent-sdk/generated/src/runtime.ts
+var BASE_PATH = "http://localhost".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;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+}
+
+class FetchError extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+}
+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))}`;
+}
+// ../agent-sdk/package.json
+var package_default = {
+  name: "@uipath/agent-sdk",
+  license: "MIT",
+  version: "1.202.0-preview.136",
+  description: "SDK for the UiPath Agent Runtime API — evaluation execution and debug sessions.",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/agent-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "agent",
+    "evaluation",
+    "sdk"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/src/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/src/index.d.ts",
+      default: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    generate: "bun run src/scripts/generate-sdk.ts",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage",
+    lint: "biome check ."
+  },
+  devDependencies: {
+    "@openapitools/openapi-generator-cli": "^2.31.1",
+    "@types/node": "^25.5.2",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../agent-sdk/src/user-agent.ts
+var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
+installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
+// ../agent-sdk/generated/src/models/LlmModel.ts
+function LlmModelFromJSON(json) {
+  return LlmModelFromJSONTyped(json, false);
+}
+function LlmModelFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    provider: json["provider"],
+    name: json["name"],
+    isPreview: json["isPreview"],
+    isSuggested: json["isSuggested"],
+    isDeprecated: json["isDeprecated"],
+    retireDate: json["retireDate"] == null ? undefined : new Date(json["retireDate"]),
+    isByo: json["isByo"],
+    byoModelConnectionId: json["byoModelConnectionId"] == null ? undefined : json["byoModelConnectionId"],
+    maxInputTokens: json["maxInputTokens"] == null ? undefined : json["maxInputTokens"],
+    maxTokens: json["maxTokens"] == null ? undefined : json["maxTokens"],
+    defaultPriority: json["defaultPriority"] == null ? undefined : json["defaultPriority"],
+    defaultConversationalPriority: json["defaultConversationalPriority"] == null ? undefined : json["defaultConversationalPriority"]
+  };
+}
+// ../agent-sdk/src/client-factory.ts
+async function createAgentRuntimeConfig(options) {
+  const ctx = await getAuthContext({
+    ensureTokenValidityMinutes: options?.loginValidity,
+    requireOrganizationId: true,
+    requireTenantId: true
+  });
+  const organizationId = ctx.organizationId;
+  const tenantId = ctx.tenantId;
+  const basePath = `${ctx.baseUrl}/${organizationId}/${tenantId}/agentsruntime_`;
+  const headers = addSdkUserAgentHeader({
+    Authorization: `Bearer ${ctx.accessToken}`,
+    "X-UiPath-Internal-TenantId": tenantId
+  }, SDK_USER_AGENT);
+  return new Configuration({
+    basePath,
+    headers
+  });
+}
+// ../agent-sdk/src/governance.ts
+async function getAgentEnforcements(options) {
+  const config = await createAgentRuntimeConfig(options);
+  const tenantId = extractTenantId(config);
+  const url = `${config.basePath}/api/designer/${encodeURIComponent(tenantId)}/governance/agentEnforcements`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: config.headers
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch agent enforcements: ${String(response.status)} ${response.statusText}`);
+  }
+  return await response.json();
+}
+async function getAvailableModels(options) {
+  const config = await createAgentRuntimeConfig(options);
+  const tenantId = extractTenantId(config);
+  const url = `${config.basePath}/api/designer/${encodeURIComponent(tenantId)}/resources/models`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: config.headers
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch available models: ${String(response.status)} ${response.statusText}`);
+  }
+  const body = await response.json();
+  const raw = Array.isArray(body) ? body : body.value ?? [];
+  return raw.map((item) => LlmModelFromJSON(item));
+}
+async function getAvailableModelNames(options) {
+  const models2 = await getAvailableModels(options);
+  return models2.map((m) => m.name).filter((n) => n != null);
+}
+function extractTenantId(config) {
+  const tenantId = config.headers?.["X-UiPath-Internal-TenantId"];
+  if (!tenantId) {
+    throw new Error("Tenant ID not found in agent runtime configuration headers.");
+  }
+  return tenantId;
+}
+// src/services/governance-fetcher.ts
+async function fetchGovernanceData() {
+  logger.info("Fetching governance enforcements...");
+  const [enforcements, modelNames] = await Promise.all([
+    getAgentEnforcements(),
+    getAvailableModelNames()
+  ]);
+  logger.info(`Governance policy "${enforcements.policyName}": maxTokens=${String(enforcements.maxTokens)}, maxTemperature=${String(enforcements.maxTemperature)}, HITL=${String(enforcements.shouldEnforceHumanInTheLoop ?? false)}`);
+  logger.info(`Available models: ${modelNames.join(", ")}`);
+  return { enforcements, modelNames };
+}
+export {
+  fetchGovernanceData
+};
+
+//# debugId=9AFD47E0BB45794264756E2164756E21