@scalar/agent-chat 0.1.2 → 0.2.0

package/helpers.d.ts

@@ -0,0 +1,418 @@
+import type { ToolUIPart, UIDataTypes, UIMessagePart } from 'ai';
+import type { MergedSecuritySchemes } from '@scalar/api-client/v2/blocks/scalar-auth-selector-block';
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+import type { AuthenticationConfiguration } from '@scalar/types/api-reference';
+import type { WorkspaceStore } from '@scalar/workspace-store/client';
+import type { WorkspaceDocument } from '@scalar/workspace-store/schemas';
+import type { XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security';
+import type { OpenApiDocument, OperationObject, ParameterObject, PathItemObject, SecurityRequirementObject, SecuritySchemeObject, ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+import { type SecuritySchemes } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+import type { Tools } from './state/state.js';
+/** Combine pathItem and operation parameters into a single, dereferenced parameter array */
+export declare const combineParams: (pathParams?: PathItemObject["parameters"], operationParams?: OperationObject["parameters"]) => ParameterObject[];
+/**
+ * Iterate through all available servers and pick the first one
+ *
+ * @example
+ * getFirstServer([operation.servers, pathItem.servers, server])
+ */
+export declare function getFirstServer(...availableServers: (ServerObject[] | ServerObject | undefined | null)[]): ServerObject | undefined;
+/** Determine if a message part is a tool */
+export declare function isToolPart(part: UIMessagePart<UIDataTypes, Tools>): part is ToolUIPart<Tools>;
+/**
+ * Extracts the default scopes for a security scheme.
+ * Only OAuth2 schemes can have default scopes via the x-default-scopes extension.
+ */
+export declare const getDefaultScopes: (scheme: SecuritySchemeObject | undefined) => string[];
+/**
+ * Determines the default security scheme to use for an operation.
+ *
+ * Priority order:
+ * 1. User-configured preferred security scheme (if provided)
+ * 2. First security requirement from the OpenAPI spec
+ * 3. null (no security required)
+ */
+export declare const getDefaultSecurity: (securityRequirements: SecurityRequirementObject[], preferredSecurityScheme: AuthenticationConfiguration["preferredSecurityScheme"], securitySchemes: MergedSecuritySchemes) => SecurityRequirementObject | null;
+/**
+ * Find the intersection between which security is selected on the document and what this operation requires
+ *
+ * If there is no overlap, we return the first requirement
+ */
+export declare const filterSelectedSecurity: (document: OpenApiDocument, operation: OperationObject | null, securitySchemes?: MergedSecuritySchemes) => SecuritySchemeObject[];
+export declare function getOperations(doc: Partial<OpenAPIV3_1.Document>): OperationObject[];
+/** Flattens all security requirements from a document */
+export declare function getSecurityFromDocument(document: WorkspaceDocument): SecuritySchemeObject[];
+/** Generate document settings from workspace store */
+export declare function createDocumentSettings(workspaceStore: WorkspaceStore): {
+    [k: string]: {
+        activeServer: ServerObject | null;
+        securitySchemes: SecuritySchemeObject[];
+    };
+};
+/**
+ * Provides an interface to store and retrieve the selected client value
+ * in local storage.
+ */
+export declare const clientStorage: () => {
+    /**
+     * Gets the stored selected client from local storage.
+     */
+    get: () => string | null;
+    /**
+     * Stores the selected client value in local storage.
+     * @param value The value to store
+     */
+    set: (value: string) => void;
+};
+/**
+ * Provides an interface to store and retrieve authentication scheme
+ * information in local storage, including both the available schemes and
+ * the user's selected schemes.
+ */
+export declare const authStorage: () => {
+    /**
+     * Retrieves and coerces the authentication schemes stored in local storage.
+     */
+    getSchemas: (slug: string) => {
+        [x: string]: ({
+            description?: string | undefined;
+        } & {
+            'x-scalar-secret-token': string;
+        } & {
+            type: "apiKey";
+            in: "header" | "query" | "cookie";
+            name: string;
+        }) | ({
+            description?: string | undefined;
+        } & {
+            'x-scalar-secret-token': string;
+        } & {
+            'x-scalar-secret-username': string;
+            'x-scalar-secret-password': string;
+        } & {
+            bearerFormat?: string | undefined;
+            type: "http";
+            scheme: "basic" | "bearer";
+        }) | ({
+            description?: string | undefined;
+        } & {
+            type: "oauth2";
+            flows: {
+                password?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    tokenUrl: string;
+                } & {
+                    'x-scalar-secret-username': string;
+                    'x-scalar-secret-password': string;
+                } & {
+                    'x-scalar-secret-client-secret': string;
+                } & {
+                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                }) | undefined;
+                implicit?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    authorizationUrl: string;
+                } & {
+                    'x-scalar-secret-redirect-uri': string;
+                }) | undefined;
+                clientCredentials?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    tokenUrl: string;
+                } & {
+                    'x-scalar-secret-client-secret': string;
+                } & {
+                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                }) | undefined;
+                authorizationCode?: ({
+                    refreshUrl: string;
+                    scopes: {
+                        [x: string]: string;
+                    };
+                } & {
+                    'x-scalar-secret-client-id': string;
+                } & {
+                    'x-scalar-secret-token': string;
+                } & {
+                    'x-scalar-security-query'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-scalar-security-body'?: {
+                        [x: string]: string;
+                    } | undefined;
+                } & {
+                    'x-tokenName'?: string | undefined;
+                } & {
+                    authorizationUrl: string;
+                    tokenUrl: string;
+                } & {
+                    'x-scalar-secret-client-secret': string;
+                } & {
+                    'x-scalar-secret-redirect-uri': string;
+                } & {
+                    'x-usePkce': "SHA-256" | "plain" | "no";
+                } & {
+                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                }) | undefined;
+            };
+        } & {
+            'x-default-scopes'?: string[] | undefined;
+        }) | ({
+            description?: string | undefined;
+        } & {
+            type: "openIdConnect";
+            openIdConnectUrl: string;
+        }) | ({
+            summary?: string | undefined;
+            description?: string | undefined;
+            $ref: string;
+        } & {
+            $status?: "error" | "loading" | undefined;
+            $global?: boolean | undefined;
+        } & {
+            '$ref-value': ({
+                description?: string | undefined;
+            } & {
+                'x-scalar-secret-token': string;
+            } & {
+                type: "apiKey";
+                in: "header" | "query" | "cookie";
+                name: string;
+            }) | ({
+                description?: string | undefined;
+            } & {
+                'x-scalar-secret-token': string;
+            } & {
+                'x-scalar-secret-username': string;
+                'x-scalar-secret-password': string;
+            } & {
+                bearerFormat?: string | undefined;
+                type: "http";
+                scheme: "basic" | "bearer";
+            }) | ({
+                description?: string | undefined;
+            } & {
+                type: "oauth2";
+                flows: {
+                    password?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        tokenUrl: string;
+                    } & {
+                        'x-scalar-secret-username': string;
+                        'x-scalar-secret-password': string;
+                    } & {
+                        'x-scalar-secret-client-secret': string;
+                    } & {
+                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    }) | undefined;
+                    implicit?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        authorizationUrl: string;
+                    } & {
+                        'x-scalar-secret-redirect-uri': string;
+                    }) | undefined;
+                    clientCredentials?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        tokenUrl: string;
+                    } & {
+                        'x-scalar-secret-client-secret': string;
+                    } & {
+                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    }) | undefined;
+                    authorizationCode?: ({
+                        refreshUrl: string;
+                        scopes: {
+                            [x: string]: string;
+                        };
+                    } & {
+                        'x-scalar-secret-client-id': string;
+                    } & {
+                        'x-scalar-secret-token': string;
+                    } & {
+                        'x-scalar-security-query'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-scalar-security-body'?: {
+                            [x: string]: string;
+                        } | undefined;
+                    } & {
+                        'x-tokenName'?: string | undefined;
+                    } & {
+                        authorizationUrl: string;
+                        tokenUrl: string;
+                    } & {
+                        'x-scalar-secret-client-secret': string;
+                    } & {
+                        'x-scalar-secret-redirect-uri': string;
+                    } & {
+                        'x-usePkce': "SHA-256" | "plain" | "no";
+                    } & {
+                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    }) | undefined;
+                };
+            } & {
+                'x-default-scopes'?: string[] | undefined;
+            }) | ({
+                description?: string | undefined;
+            } & {
+                type: "openIdConnect";
+                openIdConnectUrl: string;
+            });
+        });
+    };
+    /**
+     * Stores the authentication schemes in local storage.
+     * @param value The SecuritySchemes object to stringify and store.
+     */
+    setSchemas: (slug: string, value: SecuritySchemes) => void;
+    /**
+     * Retrieves and coerces the selected authentication schemes stored in local storage.
+     */
+    getSelectedSchemes: (slug: string) => {
+        'x-scalar-selected-security'?: {
+            selectedSchemes: {}[];
+            selectedIndex: number;
+        } | undefined;
+    };
+    /**
+     * Stores the user's selected authentication schemes in local storage.
+     * @param value The XScalarSelectedSecurity object to stringify and store.
+     */
+    setSelectedSchemes: (slug: string, value: XScalarSelectedSecurity) => void;
+};
+/**
+ * Recursively merges secret values from stored data into the current schema.
+ * Only merges secrets if the corresponding structure exists in the current schema.
+ *
+ * This function walks through both objects in parallel, copying any keys that
+ * start with 'x-scalar-secret-' from the stored object to the current object,
+ * but only if the path exists in the current schema.
+ *
+ * @param current - The current schema object (source of truth for structure)
+ * @param stored - The stored object containing secret values to restore
+ */
+export declare const mergeSecrets: (current: unknown, stored: unknown) => void;
+/**
+ * Restores authentication secrets from local storage to the workspace store.
+ *
+ * This function iterates through stored authentication schemes and restores
+ * any secret values (keys starting with x-scalar-secret-) to the active
+ * document's security schemes. It uses the current security schemes as the
+ * source of truth, only restoring secrets for structures that exist in the
+ * current document.
+ */
+export declare const restoreAuthSecretsFromStorage: ({ documentName, workspaceStore, }: {
+    documentName: string;
+    workspaceStore: WorkspaceStore;
+}) => void;
+export declare function safeParseJson(value: string): any;
+//# sourceMappingURL=helpers.d.ts.map

package/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"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"}

package/helpers.js

@@ -0,0 +1,201 @@
+import { getSecuritySchemes } from "@scalar/api-client/v2/blocks/operation-block";
+import { getSelectedSecurity, getSelectedServer } from "@scalar/api-client/v2/features/operation";
+import { isDefined } from "@scalar/helpers/array/is-defined";
+import { isObject } from "@scalar/helpers/object/is-object";
+import { REFERENCE_LS_KEYS, safeLocalStorage } from "@scalar/helpers/object/local-storage";
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { coerceValue } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { XScalarSelectedSecuritySchema, SecuritySchemesSchema } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
+const combineParams = (pathParams = [], operationParams = []) => {
+  const allParams = [...pathParams, ...operationParams].map((param) => getResolvedRef(param)).filter((e) => isDefined(e) && e.name);
+  const uniqueParams = /* @__PURE__ */ new Map();
+  for (const param of allParams) {
+    const key = `${param.in}:${param.name}`;
+    uniqueParams.set(key, param);
+  }
+  return Array.from(uniqueParams.values());
+};
+function getFirstServer(...availableServers) {
+  for (const serverSource of availableServers) {
+    if (!serverSource) {
+      continue;
+    }
+    if (!Array.isArray(serverSource)) {
+      const resolvedServer = getResolvedRef(serverSource);
+      if (resolvedServer?.url) {
+        return resolvedServer;
+      }
+      continue;
+    }
+    for (const server of serverSource) {
+      const resolvedServer = getResolvedRef(server);
+      if (resolvedServer?.url) {
+        return resolvedServer;
+      }
+    }
+  }
+  return void 0;
+}
+const getKey = (requirement) => Object.keys(requirement).sort().join(",");
+const filterSelectedSecurity = (document, operation, securitySchemes = {}) => {
+  const securityRequirements = operation?.security ?? document.security ?? [];
+  const selectedSecurity = getSelectedSecurity(
+    document?.["x-scalar-selected-security"],
+    operation?.["x-scalar-selected-security"]
+  );
+  const requirementSet = new Set(securityRequirements.map((r) => getKey(r)));
+  const selectedRequirement = selectedSecurity.selectedSchemes[selectedSecurity.selectedIndex];
+  if (selectedRequirement && requirementSet.has(getKey(selectedRequirement))) {
+    return getSecuritySchemes(securitySchemes, [selectedRequirement]);
+  }
+  for (const selected of selectedSecurity.selectedSchemes) {
+    if (requirementSet.has(getKey(selected))) {
+      return getSecuritySchemes(securitySchemes, [selected]);
+    }
+  }
+  if (operation?.security?.length && !document?.["x-scalar-set-operation-security"]) {
+    return getSecuritySchemes(securitySchemes, securityRequirements.slice(0, 1));
+  }
+  return [];
+};
+function getOperations(doc) {
+  return Object.values(doc.paths ?? {}).flatMap(
+    (path) => Object.values(path ?? {})
+  );
+}
+function getSecurityFromDocument(document) {
+  const selectedSchemes = document["x-scalar-selected-security"]?.selectedSchemes ?? [];
+  const schemeKeys = selectedSchemes.flatMap((scheme) => Object.keys(scheme));
+  const securitySchemes = document.components?.securitySchemes;
+  if (!securitySchemes) return [];
+  return schemeKeys.reduce((acc, cur) => {
+    const security = securitySchemes[cur];
+    if (security) acc.push(getResolvedRef(security));
+    return acc;
+  }, []);
+}
+function createDocumentSettings(workspaceStore) {
+  return Object.fromEntries(
+    Object.entries(workspaceStore.workspace.documents).map(
+      ([key, document]) => [
+        key,
+        {
+          activeServer: getSelectedServer(document),
+          securitySchemes: getSecurityFromDocument(document)
+        }
+      ]
+    )
+  );
+}
+const storage = safeLocalStorage();
+const authStorage = () => {
+  const schemasKey = REFERENCE_LS_KEYS.AUTH_SCHEMES;
+  const selectedSchemesKey = REFERENCE_LS_KEYS.SELECTED_AUTH_SCHEMES;
+  const getAuthId = (type, prefix) => {
+    const getKey2 = (type2) => {
+      return type2 === "schemas" ? schemasKey : selectedSchemesKey;
+    };
+    return `${prefix}-${getKey2(type)}`;
+  };
+  return {
+    /**
+     * Retrieves and coerces the authentication schemes stored in local storage.
+     */
+    getSchemas: (slug) => {
+      const parsed = JSON.parse(
+        storage.getItem(getAuthId("schemas", slug)) ?? "{}"
+      );
+      return coerceValue(SecuritySchemesSchema, parsed);
+    },
+    /**
+     * Stores the authentication schemes in local storage.
+     * @param value The SecuritySchemes object to stringify and store.
+     */
+    setSchemas: (slug, value) => {
+      storage.setItem(getAuthId("schemas", slug), JSON.stringify(value));
+    },
+    /**
+     * Retrieves and coerces the selected authentication schemes stored in local storage.
+     */
+    getSelectedSchemes: (slug) => {
+      const parsed = JSON.parse(
+        storage.getItem(getAuthId("selectedSchemes", slug)) ?? "{}"
+      );
+      return coerceValue(XScalarSelectedSecuritySchema, parsed);
+    },
+    /**
+     * Stores the user's selected authentication schemes in local storage.
+     * @param value The XScalarSelectedSecurity object to stringify and store.
+     */
+    setSelectedSchemes: (slug, value) => {
+      storage.setItem(getAuthId("selectedSchemes", slug), JSON.stringify(value));
+    }
+  };
+};
+const mergeSecrets = (current, stored) => {
+  if (!isObject(current) || !isObject(stored)) {
+    return;
+  }
+  for (const [key, storedValue] of Object.entries(stored)) {
+    if (typeof storedValue !== "object") {
+      current[key] = storedValue;
+      continue;
+    }
+    mergeSecrets(getResolvedRef(current[key]), storedValue);
+  }
+};
+const isSchemeValid = (scheme, availableSchemes) => Object.keys(scheme).every((key) => availableSchemes.has(key));
+const clampSelectedIndex = (selectedIndex, schemesLength) => selectedIndex >= schemesLength ? schemesLength - 1 : selectedIndex;
+const restoreAuthSecretsFromStorage = ({
+  documentName,
+  workspaceStore
+}) => {
+  const storedAuthSchemes = authStorage().getSchemas(documentName);
+  const document = workspaceStore.workspace.documents[documentName];
+  if (!document) return;
+  const authPersistence = authStorage();
+  const storedSelectedAuthSchemes = authPersistence.getSelectedSchemes(documentName);
+  const availableSchemes = new Set(
+    Object.keys(document.components?.securitySchemes ?? {})
+  );
+  const selectedSchemes = storedSelectedAuthSchemes["x-scalar-selected-security"]?.selectedSchemes;
+  const validSchemes = selectedSchemes?.filter(
+    (scheme) => isSchemeValid(scheme, availableSchemes)
+  );
+  if (!document["x-scalar-selected-security"] && validSchemes && validSchemes.length > 0) {
+    const selectedIdx = storedSelectedAuthSchemes["x-scalar-selected-security"]?.selectedIndex;
+    const clampedIndex = clampSelectedIndex(
+      selectedIdx ?? 0,
+      validSchemes.length
+    );
+    document["x-scalar-selected-security"] = {
+      selectedIndex: clampedIndex,
+      selectedSchemes: validSchemes
+    };
+  }
+  const securitySchemes = document.components?.securitySchemes ?? {};
+  for (const [key, storedScheme] of Object.entries(storedAuthSchemes)) {
+    const currentScheme = getResolvedRef(securitySchemes[key]);
+    if (isObject(currentScheme)) mergeSecrets(currentScheme, storedScheme);
+  }
+};
+function safeParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
+export {
+  authStorage,
+  combineParams,
+  createDocumentSettings,
+  filterSelectedSecurity,
+  getFirstServer,
+  getOperations,
+  getSecurityFromDocument,
+  mergeSecrets,
+  restoreAuthSecretsFromStorage,
+  safeParseJson
+};
+//# sourceMappingURL=helpers.js.map

package/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sources":["../src/helpers.ts"],"sourcesContent":["import type { ToolUIPart, UIDataTypes, UIMessagePart } from 'ai'\n\nimport { getSecuritySchemes } from '@scalar/api-client/v2/blocks/operation-block'\nimport type { MergedSecuritySchemes } from '@scalar/api-client/v2/blocks/scalar-auth-selector-block'\nimport {\n  getSelectedSecurity,\n  getSelectedServer,\n} from '@scalar/api-client/v2/features/operation'\nimport { isDefined } from '@scalar/helpers/array/is-defined'\nimport { isObject } from '@scalar/helpers/object/is-object'\nimport {\n  REFERENCE_LS_KEYS,\n  safeLocalStorage,\n} from '@scalar/helpers/object/local-storage'\nimport type { OpenAPIV3_1 } from '@scalar/openapi-types'\nimport type { AuthenticationConfiguration } from '@scalar/types/api-reference'\nimport type { WorkspaceStore } from '@scalar/workspace-store/client'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport { unpackProxyObject } from '@scalar/workspace-store/helpers/unpack-proxy'\nimport type { WorkspaceDocument } from '@scalar/workspace-store/schemas'\nimport type { XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security'\nimport { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce'\nimport type {\n  OpenApiDocument,\n  OperationObject,\n  ParameterObject,\n  PathItemObject,\n  SecurityRequirementObject,\n  SecuritySchemeObject,\n  ServerObject,\n} from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\nimport {\n  type SecuritySchemes,\n  SecuritySchemesSchema,\n  XScalarSelectedSecuritySchema,\n} from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport type { Tools } from '@/state/state'\n\n/** Combine pathItem and operation parameters into a single, dereferenced parameter array */\nexport const combineParams = (\n  pathParams: PathItemObject['parameters'] = [],\n  operationParams: OperationObject['parameters'] = [],\n): ParameterObject[] => {\n  const allParams = [...pathParams, ...operationParams]\n    .map((param) => getResolvedRef(param))\n    // For unresolved params, coercion is going to generate a template object with an empty name, we don't want to include those\n    .filter((e) => isDefined(e) && e.name)\n\n  // Use a Map to ensure unique in+name combinations\n  // Operation parameters take precedence over path parameters\n  const uniqueParams = new Map<string, ParameterObject>()\n\n  for (const param of allParams) {\n    const key = `${param.in}:${param.name}`\n    uniqueParams.set(key, param)\n  }\n\n  return Array.from(uniqueParams.values())\n}\n\n/**\n * Iterate through all available servers and pick the first one\n *\n * @example\n * getFirstServer([operation.servers, pathItem.servers, server])\n */\nexport function getFirstServer(\n  ...availableServers: (ServerObject[] | ServerObject | undefined | null)[]\n): ServerObject | undefined {\n  for (const serverSource of availableServers) {\n    if (!serverSource) {\n      continue\n    }\n\n    // Handle single server object\n    if (!Array.isArray(serverSource)) {\n      const resolvedServer = getResolvedRef(serverSource) as ServerObject\n      if (resolvedServer?.url) {\n        return resolvedServer\n      }\n      continue\n    }\n\n    // Handle array of servers, pick the first one with a URL\n    for (const server of serverSource) {\n      const resolvedServer = getResolvedRef(server) as ServerObject\n      if (resolvedServer?.url) {\n        return resolvedServer\n      }\n    }\n  }\n\n  return undefined\n}\n\n/** Determine if a message part is a tool */\nexport function isToolPart(\n  part: UIMessagePart<UIDataTypes, Tools>,\n): part is ToolUIPart<Tools> {\n  return part.type.startsWith('tool-')\n}\n\n/**\n * Extracts the default scopes for a security scheme.\n * Only OAuth2 schemes can have default scopes via the x-default-scopes extension.\n */\nexport const getDefaultScopes = (\n  scheme: SecuritySchemeObject | undefined,\n): string[] => {\n  if (!scheme || scheme.type !== 'oauth2') {\n    return []\n  }\n\n  return scheme['x-default-scopes'] ?? []\n}\n\n/**\n * Processes a single scheme name and adds it to the accumulator with its default scopes.\n */\nconst addSchemeToRequirement = (\n  acc: SecurityRequirementObject,\n  schemeName: string,\n  securitySchemes: MergedSecuritySchemes,\n): void => {\n  const scheme = getResolvedRef(securitySchemes[schemeName])\n  acc[schemeName] = getDefaultScopes(scheme)\n}\n\n/**\n * Converts the preferred security scheme configuration into a SecurityRequirementObject.\n * Handles both flat arrays and nested arrays (for complex auth scenarios).\n */\nconst buildSecurityRequirementFromPreferred = (\n  preferredSecurityScheme: string | (string | string[])[],\n  securitySchemes: MergedSecuritySchemes,\n): SecurityRequirementObject => {\n  if (!Array.isArray(preferredSecurityScheme)) {\n    const scheme = getResolvedRef(securitySchemes[preferredSecurityScheme])\n    return { [preferredSecurityScheme]: getDefaultScopes(scheme) }\n  }\n\n  const requirement: SecurityRequirementObject = {}\n\n  for (const item of preferredSecurityScheme) {\n    if (Array.isArray(item)) {\n      // Handle nested arrays for complex auth (e.g., [['oauth2', 'apiKey'], 'basic'])\n      for (const schemeName of item) {\n        addSchemeToRequirement(requirement, schemeName, securitySchemes)\n      }\n    } else {\n      addSchemeToRequirement(requirement, item, securitySchemes)\n    }\n  }\n\n  return requirement\n}\n\n/**\n * Determines the default security scheme to use for an operation.\n *\n * Priority order:\n * 1. User-configured preferred security scheme (if provided)\n * 2. First security requirement from the OpenAPI spec\n * 3. null (no security required)\n */\nexport const getDefaultSecurity = (\n  securityRequirements: SecurityRequirementObject[],\n  preferredSecurityScheme: AuthenticationConfiguration['preferredSecurityScheme'],\n  securitySchemes: MergedSecuritySchemes,\n): SecurityRequirementObject | null => {\n  if (preferredSecurityScheme) {\n    return buildSecurityRequirementFromPreferred(\n      preferredSecurityScheme,\n      securitySchemes,\n    )\n  }\n\n  const firstRequirement = securityRequirements[0]\n  if (firstRequirement) {\n    return unpackProxyObject(firstRequirement, { depth: 1 })\n  }\n\n  return null\n}\n\n/** Builds a quick cache key from the sorted object keys */\nconst getKey = (requirement: SecurityRequirementObject) =>\n  Object.keys(requirement).sort().join(',')\n\n/**\n * Find the intersection between which security is selected on the document and what this operation requires\n *\n * If there is no overlap, we return the first requirement\n */\nexport const filterSelectedSecurity = (\n  document: OpenApiDocument,\n  operation: OperationObject | null,\n  securitySchemes: MergedSecuritySchemes = {},\n): SecuritySchemeObject[] => {\n  const securityRequirements = operation?.security ?? document.security ?? []\n\n  /** The selected security keys for the document */\n  const selectedSecurity = getSelectedSecurity(\n    document?.['x-scalar-selected-security'],\n    operation?.['x-scalar-selected-security'],\n  )\n\n  /** Build a set for O(1) lookup */\n  const requirementSet = new Set(securityRequirements.map((r) => getKey(r)))\n\n  // Lets check the selectedIndex first\n  const selectedRequirement =\n    selectedSecurity.selectedSchemes[selectedSecurity.selectedIndex]\n  if (selectedRequirement && requirementSet.has(getKey(selectedRequirement))) {\n    return getSecuritySchemes(securitySchemes, [selectedRequirement])\n  }\n\n  // Otherwise lets loop over all selected\n  for (const selected of selectedSecurity.selectedSchemes) {\n    if (requirementSet.has(getKey(selected))) {\n      return getSecuritySchemes(securitySchemes, [selected])\n    }\n  }\n\n  /**\n   * If we are selected security on the document,\n   * we should show the first requirement of the operation to show auth is required\n   */\n  if (\n    operation?.security?.length &&\n    !document?.['x-scalar-set-operation-security']\n  ) {\n    return getSecuritySchemes(securitySchemes, securityRequirements.slice(0, 1))\n  }\n\n  return []\n}\n\nexport function getOperations(doc: Partial<OpenAPIV3_1.Document>) {\n  return Object.values(doc.paths ?? {}).flatMap((path) =>\n    Object.values(path ?? {}),\n  ) as OperationObject[]\n}\n\n/** Flattens all security requirements from a document */\nexport function getSecurityFromDocument(document: WorkspaceDocument) {\n  const selectedSchemes =\n    document['x-scalar-selected-security']?.selectedSchemes ?? []\n\n  const schemeKeys = selectedSchemes.flatMap((scheme) => Object.keys(scheme))\n\n  const securitySchemes = document.components?.securitySchemes\n\n  if (!securitySchemes) return []\n\n  return schemeKeys.reduce<SecuritySchemeObject[]>((acc, cur) => {\n    const security = securitySchemes[cur]\n\n    if (security) acc.push(getResolvedRef(security))\n\n    return acc\n  }, [])\n}\n\n/** Generate document settings from workspace store */\nexport function createDocumentSettings(workspaceStore: WorkspaceStore) {\n  return Object.fromEntries(\n    Object.entries(workspaceStore.workspace.documents).map(\n      ([key, document]) => [\n        key,\n        {\n          activeServer: getSelectedServer(document),\n          securitySchemes: getSecurityFromDocument(document),\n        },\n      ],\n    ),\n  )\n}\n\n// Local storage helper instance, safely wrapped.\nconst storage = safeLocalStorage()\n\n/**\n * Provides an interface to store and retrieve the selected client value\n * in local storage.\n */\nexport const clientStorage = () => {\n  const key = REFERENCE_LS_KEYS.SELECTED_CLIENT\n  return {\n    /**\n     * Gets the stored selected client from local storage.\n     */\n    get: () => {\n      return storage.getItem(key)\n    },\n    /**\n     * Stores the selected client value in local storage.\n     * @param value The value to store\n     */\n    set: (value: string) => {\n      storage.setItem(key, value as string)\n    },\n  }\n}\n\n/**\n * Provides an interface to store and retrieve authentication scheme\n * information in local storage, including both the available schemes and\n * the user's selected schemes.\n */\nexport const authStorage = () => {\n  const schemasKey = REFERENCE_LS_KEYS.AUTH_SCHEMES\n  const selectedSchemesKey = REFERENCE_LS_KEYS.SELECTED_AUTH_SCHEMES\n\n  const getAuthId = (type: 'schemas' | 'selectedSchemes', prefix: string) => {\n    const getKey = (type: 'schemas' | 'selectedSchemes') => {\n      return type === 'schemas' ? schemasKey : selectedSchemesKey\n    }\n    return `${prefix}-${getKey(type)}`\n  }\n\n  return {\n    /**\n     * Retrieves and coerces the authentication schemes stored in local storage.\n     */\n    getSchemas: (slug: string) => {\n      const parsed = JSON.parse(\n        storage.getItem(getAuthId('schemas', slug)) ?? '{}',\n      )\n      return coerceValue(SecuritySchemesSchema, parsed)\n    },\n    /**\n     * Stores the authentication schemes in local storage.\n     * @param value The SecuritySchemes object to stringify and store.\n     */\n    setSchemas: (slug: string, value: SecuritySchemes) => {\n      storage.setItem(getAuthId('schemas', slug), JSON.stringify(value))\n    },\n    /**\n     * Retrieves and coerces the selected authentication schemes stored in local storage.\n     */\n    getSelectedSchemes: (slug: string) => {\n      const parsed = JSON.parse(\n        storage.getItem(getAuthId('selectedSchemes', slug)) ?? '{}',\n      )\n      return coerceValue(XScalarSelectedSecuritySchema, parsed)\n    },\n    /**\n     * Stores the user's selected authentication schemes in local storage.\n     * @param value The XScalarSelectedSecurity object to stringify and store.\n     */\n    setSelectedSchemes: (slug: string, value: XScalarSelectedSecurity) => {\n      storage.setItem(getAuthId('selectedSchemes', slug), JSON.stringify(value))\n    },\n  }\n}\n\n/**\n * Recursively merges secret values from stored data into the current schema.\n * Only merges secrets if the corresponding structure exists in the current schema.\n *\n * This function walks through both objects in parallel, copying any keys that\n * start with 'x-scalar-secret-' from the stored object to the current object,\n * but only if the path exists in the current schema.\n *\n * @param current - The current schema object (source of truth for structure)\n * @param stored - The stored object containing secret values to restore\n */\nexport const mergeSecrets = (current: unknown, stored: unknown): void => {\n  if (!isObject(current) || !isObject(stored)) {\n    return\n  }\n\n  // Iterate through stored keys to find secrets to restore\n  for (const [key, storedValue] of Object.entries(stored)) {\n    // If this is a secret key and it has a value, restore it to current\n    if (typeof storedValue !== 'object') {\n      current[key] = storedValue\n      continue\n    }\n\n    // If the value is an object (and not null), recurse into it\n    mergeSecrets(getResolvedRef(current[key]), storedValue)\n  }\n}\n\ntype SelectedSecurityScheme = NonNullable<\n  XScalarSelectedSecurity['x-scalar-selected-security']\n>['selectedSchemes'][number]\n\n/**\n * Validates that all keys in a security scheme exist in the available schemes.\n */\nconst isSchemeValid = (\n  scheme: SelectedSecurityScheme,\n  availableSchemes: Set<string>,\n): boolean => Object.keys(scheme).every((key) => availableSchemes.has(key))\n\n/**\n * Clamps the selected index to be within the valid range of schemes.\n * If the index is out of bounds, returns the last valid index.\n */\nconst clampSelectedIndex = (\n  selectedIndex: number,\n  schemesLength: number,\n): number =>\n  selectedIndex >= schemesLength ? schemesLength - 1 : selectedIndex\n\n/**\n * Restores authentication secrets from local storage to the workspace store.\n *\n * This function iterates through stored authentication schemes and restores\n * any secret values (keys starting with x-scalar-secret-) to the active\n * document's security schemes. It uses the current security schemes as the\n * source of truth, only restoring secrets for structures that exist in the\n * current document.\n */\nexport const restoreAuthSecretsFromStorage = ({\n  documentName,\n  workspaceStore,\n}: {\n  documentName: string\n  workspaceStore: WorkspaceStore\n}): void => {\n  const storedAuthSchemes = authStorage().getSchemas(documentName)\n\n  const document = workspaceStore.workspace.documents[documentName]\n\n  if (!document) return\n\n  const authPersistence = authStorage()\n\n  const storedSelectedAuthSchemes =\n    authPersistence.getSelectedSchemes(documentName)\n\n  const availableSchemes = new Set(\n    Object.keys(document.components?.securitySchemes ?? {}),\n  )\n\n  const selectedSchemes =\n    storedSelectedAuthSchemes['x-scalar-selected-security']?.selectedSchemes\n\n  const validSchemes = selectedSchemes?.filter((scheme) =>\n    isSchemeValid(scheme, availableSchemes),\n  )\n\n  if (\n    !document['x-scalar-selected-security'] &&\n    validSchemes &&\n    validSchemes.length > 0\n  ) {\n    const selectedIdx =\n      storedSelectedAuthSchemes['x-scalar-selected-security']?.selectedIndex\n\n    const clampedIndex = clampSelectedIndex(\n      selectedIdx ?? 0,\n      validSchemes.length,\n    )\n\n    document['x-scalar-selected-security'] = {\n      selectedIndex: clampedIndex,\n      selectedSchemes: validSchemes,\n    }\n  }\n\n  const securitySchemes = document.components?.securitySchemes ?? {}\n\n  for (const [key, storedScheme] of Object.entries(storedAuthSchemes)) {\n    const currentScheme = getResolvedRef(securitySchemes[key])\n\n    if (isObject(currentScheme)) mergeSecrets(currentScheme, storedScheme)\n  }\n}\n\nexport function safeParseJson(value: string) {\n  try {\n    return JSON.parse(value)\n  } catch {\n    return\n  }\n}\n"],"names":["getKey","type"],"mappings":"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"}