@executor-js/plugin-openapi 1.5.6 → 1.5.7

package/dist/{chunk-YVRI7KRC.js → chunk-C3IJX4AN.js}

@@ -1,125 +1,27 @@
-// src/sdk/types.ts
-import { Schema } from "effect";
-var variable = (name) => ({
-  type: "variable",
-  name
-});
-var TOKEN_VARIABLE = "token";
-var OperationId = Schema.String.pipe(Schema.brand("OperationId"));
-var HttpMethod = Schema.Literals([
-  "get",
-  "put",
-  "post",
-  "delete",
-  "patch",
-  "head",
-  "options",
-  "trace"
-]);
-var ParameterLocation = Schema.Literals(["path", "query", "header", "cookie"]);
-var OperationParameter = Schema.Struct({
-  name: Schema.String,
-  location: ParameterLocation,
-  required: Schema.Boolean,
-  schema: Schema.OptionFromOptional(Schema.Unknown),
-  style: Schema.OptionFromOptional(Schema.String),
-  explode: Schema.OptionFromOptional(Schema.Boolean),
-  allowReserved: Schema.OptionFromOptional(Schema.Boolean),
-  description: Schema.OptionFromOptional(Schema.String)
-});
-var EncodingObject = Schema.Struct({
-  contentType: Schema.OptionFromOptional(Schema.String),
-  style: Schema.OptionFromOptional(Schema.String),
-  explode: Schema.OptionFromOptional(Schema.Boolean),
-  allowReserved: Schema.OptionFromOptional(Schema.Boolean)
-});
-var MediaBinding = Schema.Struct({
-  contentType: Schema.String,
-  schema: Schema.OptionFromOptional(Schema.Unknown),
-  encoding: Schema.OptionFromOptional(Schema.Record(Schema.String, EncodingObject))
-});
-var OperationRequestBody = Schema.Struct({
-  required: Schema.Boolean,
-  /** Default media type — first declared in spec order (not JSON-first).
-   *  Used when the caller does not override via the tool's `contentType` arg. */
-  contentType: Schema.String,
-  /** Schema of the default media type. Kept for backward compat with stored
-   *  bindings from before `contents` was added. */
-  schema: Schema.OptionFromOptional(Schema.Unknown),
-  /** All declared media types in spec order. Populated by `extract.ts`
-   *  going forward; older persisted bindings may have this unset and will
-   *  fall back to `{contentType, schema}`. */
-  contents: Schema.OptionFromOptional(Schema.Array(MediaBinding))
-});
-var ExtractedOperation = Schema.Struct({
-  operationId: OperationId,
-  toolPath: Schema.OptionFromOptional(Schema.String),
-  method: HttpMethod,
-  baseUrl: Schema.optional(Schema.String),
-  pathTemplate: Schema.String,
-  summary: Schema.OptionFromOptional(Schema.String),
-  description: Schema.OptionFromOptional(Schema.String),
-  tags: Schema.Array(Schema.String),
-  parameters: Schema.Array(OperationParameter),
-  requestBody: Schema.OptionFromOptional(OperationRequestBody),
-  inputSchema: Schema.OptionFromOptional(Schema.Unknown),
-  outputSchema: Schema.OptionFromOptional(Schema.Unknown),
-  deprecated: Schema.Boolean
-});
-var ServerVariable = Schema.Struct({
-  default: Schema.String,
-  enum: Schema.OptionFromOptional(Schema.Array(Schema.String)),
-  description: Schema.OptionFromOptional(Schema.String)
-});
-var ServerInfo = Schema.Struct({
-  url: Schema.String,
-  description: Schema.OptionFromOptional(Schema.String),
-  variables: Schema.OptionFromOptional(Schema.Record(Schema.String, ServerVariable))
-});
-var ExtractionResult = Schema.Struct({
-  title: Schema.OptionFromOptional(Schema.String),
-  version: Schema.OptionFromOptional(Schema.String),
-  servers: Schema.Array(ServerInfo),
-  operations: Schema.Array(ExtractedOperation)
-});
-var OperationBinding = Schema.Struct({
-  method: HttpMethod,
-  baseUrl: Schema.optional(Schema.String),
-  pathTemplate: Schema.String,
-  parameters: Schema.Array(OperationParameter),
-  requestBody: Schema.OptionFromOptional(OperationRequestBody)
-});
-var InvocationResult = Schema.Struct({
-  status: Schema.Number,
-  headers: Schema.Record(Schema.String, Schema.String),
-  data: Schema.NullOr(Schema.Unknown),
-  error: Schema.NullOr(Schema.Unknown)
-});
-
 // src/sdk/errors.ts
-import { Data, Schema as Schema2 } from "effect";
-var OpenApiParseError = class extends Schema2.TaggedErrorClass()(
+import { Data, Schema } from "effect";
+var OpenApiParseError = class extends Schema.TaggedErrorClass()(
   "OpenApiParseError",
   {
-    message: Schema2.String
+    message: Schema.String
   },
   { httpApiStatus: 400 }
 ) {
 };
-var OpenApiExtractionError = class extends Schema2.TaggedErrorClass()(
+var OpenApiExtractionError = class extends Schema.TaggedErrorClass()(
   "OpenApiExtractionError",
   {
-    message: Schema2.String
+    message: Schema.String
   },
   { httpApiStatus: 400 }
 ) {
 };
 var OpenApiInvocationError = class extends Data.TaggedError("OpenApiInvocationError") {
 };
-var OpenApiOAuthError = class extends Schema2.TaggedErrorClass()(
+var OpenApiOAuthError = class extends Schema.TaggedErrorClass()(
   "OpenApiOAuthError",
   {
-    message: Schema2.String
+    message: Schema.String
   },
   { httpApiStatus: 400 }
 ) {
@@ -128,7 +30,7 @@ var OpenApiAuthRequiredError = class extends Data.TaggedError("OpenApiAuthRequir
 };
 
 // src/sdk/parse.ts
-import { Duration, Effect, Schema as Schema3 } from "effect";
+import { Duration, Effect, Schema as Schema2 } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/unstable/http";
 import YAML from "yaml";
 var OpenApiExtractionErrorFromParse = class extends OpenApiExtractionError {
@@ -198,7 +100,7 @@ var parseTextToObject = (text) => Effect.gen(function* () {
   }
   return parsed;
 });
-var parseJsonText = Schema3.decodeUnknownEffect(Schema3.fromJsonString(Schema3.Unknown));
+var parseJsonText = Schema2.decodeUnknownEffect(Schema2.fromJsonString(Schema2.Unknown));
 var parseJsonLike = (text) => {
   const parseYaml = Effect.try({
     try: () => YAML.parse(text),
@@ -209,7 +111,6 @@ var parseJsonLike = (text) => {
 };
 
 // src/sdk/openapi-utils.ts
-import { Option } from "effect";
 var DocResolver = class {
   constructor(doc) {
     this.doc = doc;
@@ -242,33 +143,13 @@ var substituteUrlVariables = (url, values) => {
   }
   return out;
 };
-var OPENAPI_MAX_SERVER_VARIABLE_OPTIONS = 64;
-var expandServerUrlOptions = (server, limit = OPENAPI_MAX_SERVER_VARIABLE_OPTIONS) => {
-  if (!Option.isSome(server.variables)) return [server.url];
-  let urls = [server.url];
-  for (const [name, variable2] of Object.entries(server.variables.value)) {
-    const enumValues = typeof variable2 === "string" ? [] : Option.getOrElse(variable2.enum, () => []);
-    const values = enumValues.length > 0 ? enumValues : [typeof variable2 === "string" ? variable2 : variable2.default];
-    const next = [];
-    for (const url of urls) {
-      for (const value of values) {
-        next.push(url.replaceAll(`{${name}}`, value));
-        if (next.length >= limit) return next;
-      }
-    }
-    urls = next;
-  }
-  return urls;
-};
-var resolveBaseUrl = (servers) => {
-  const server = servers[0];
-  if (!server) return "";
-  if (!Option.isSome(server.variables)) return server.url;
+var resolveServerUrl = (templateUrl, variables, overrides) => {
   const values = {};
-  for (const [name, v] of Object.entries(server.variables.value)) {
-    values[name] = typeof v === "string" ? v : v.default;
+  for (const [name, v] of Object.entries(variables ?? {})) values[name] = v.default;
+  for (const [name, value] of Object.entries(overrides)) {
+    if (value) values[name] = value;
   }
-  return substituteUrlVariables(server.url, values);
+  return substituteUrlVariables(templateUrl, values);
 };
 var declaredContents = (content) => {
   if (!content) return [];
@@ -285,8 +166,114 @@ var preferredResponseContent = (content) => {
   return pick ? { mediaType: pick[0], media: pick[1] } : void 0;
 };
 
+// src/sdk/types.ts
+import { Schema as Schema3 } from "effect";
+import { AuthTemplateSlug } from "@executor-js/sdk/shared";
+import {
+  apiKeyMethodFromAuthTemplate,
+  isApiKeyAuthTemplate
+} from "@executor-js/sdk/http-auth";
+import { TOKEN_VARIABLE } from "@executor-js/sdk/http-auth";
+var normalizeOpenApiAuthInputs = (inputs) => inputs.map((input) => {
+  if (!isApiKeyAuthTemplate(input)) {
+    return { ...input, slug: AuthTemplateSlug.make(input.slug) };
+  }
+  const method = apiKeyMethodFromAuthTemplate(input);
+  return { ...method, slug: method.slug ?? "" };
+});
+var OperationId = Schema3.String.pipe(Schema3.brand("OperationId"));
+var HttpMethod = Schema3.Literals([
+  "get",
+  "put",
+  "post",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace"
+]);
+var ParameterLocation = Schema3.Literals(["path", "query", "header", "cookie"]);
+var OperationParameter = Schema3.Struct({
+  name: Schema3.String,
+  location: ParameterLocation,
+  required: Schema3.Boolean,
+  schema: Schema3.OptionFromOptional(Schema3.Unknown),
+  style: Schema3.OptionFromOptional(Schema3.String),
+  explode: Schema3.OptionFromOptional(Schema3.Boolean),
+  allowReserved: Schema3.OptionFromOptional(Schema3.Boolean),
+  description: Schema3.OptionFromOptional(Schema3.String)
+});
+var EncodingObject = Schema3.Struct({
+  contentType: Schema3.OptionFromOptional(Schema3.String),
+  style: Schema3.OptionFromOptional(Schema3.String),
+  explode: Schema3.OptionFromOptional(Schema3.Boolean),
+  allowReserved: Schema3.OptionFromOptional(Schema3.Boolean)
+});
+var MediaBinding = Schema3.Struct({
+  contentType: Schema3.String,
+  schema: Schema3.OptionFromOptional(Schema3.Unknown),
+  encoding: Schema3.OptionFromOptional(Schema3.Record(Schema3.String, EncodingObject))
+});
+var OperationRequestBody = Schema3.Struct({
+  required: Schema3.Boolean,
+  /** Default media type — first declared in spec order (not JSON-first).
+   *  Used when the caller does not override via the tool's `contentType` arg. */
+  contentType: Schema3.String,
+  /** Schema of the default media type. Kept for backward compat with stored
+   *  bindings from before `contents` was added. */
+  schema: Schema3.OptionFromOptional(Schema3.Unknown),
+  /** All declared media types in spec order. Populated by `extract.ts`
+   *  going forward; older persisted bindings may have this unset and will
+   *  fall back to `{contentType, schema}`. */
+  contents: Schema3.OptionFromOptional(Schema3.Array(MediaBinding))
+});
+var ServerVariable = Schema3.Struct({
+  default: Schema3.String,
+  enum: Schema3.OptionFromOptional(Schema3.Array(Schema3.String)),
+  description: Schema3.OptionFromOptional(Schema3.String)
+});
+var ServerInfo = Schema3.Struct({
+  url: Schema3.String,
+  description: Schema3.OptionFromOptional(Schema3.String),
+  variables: Schema3.OptionFromOptional(Schema3.Record(Schema3.String, ServerVariable))
+});
+var ExtractedOperation = Schema3.Struct({
+  operationId: OperationId,
+  toolPath: Schema3.OptionFromOptional(Schema3.String),
+  method: HttpMethod,
+  servers: Schema3.Array(ServerInfo),
+  pathTemplate: Schema3.String,
+  summary: Schema3.OptionFromOptional(Schema3.String),
+  description: Schema3.OptionFromOptional(Schema3.String),
+  tags: Schema3.Array(Schema3.String),
+  parameters: Schema3.Array(OperationParameter),
+  requestBody: Schema3.OptionFromOptional(OperationRequestBody),
+  inputSchema: Schema3.OptionFromOptional(Schema3.Unknown),
+  outputSchema: Schema3.OptionFromOptional(Schema3.Unknown),
+  deprecated: Schema3.Boolean
+});
+var ExtractionResult = Schema3.Struct({
+  title: Schema3.OptionFromOptional(Schema3.String),
+  version: Schema3.OptionFromOptional(Schema3.String),
+  servers: Schema3.Array(ServerInfo),
+  operations: Schema3.Array(ExtractedOperation)
+});
+var OperationBinding = Schema3.Struct({
+  method: HttpMethod,
+  servers: Schema3.optional(Schema3.Array(ServerInfo)),
+  pathTemplate: Schema3.String,
+  parameters: Schema3.Array(OperationParameter),
+  requestBody: Schema3.OptionFromOptional(OperationRequestBody)
+});
+var InvocationResult = Schema3.Struct({
+  status: Schema3.Number,
+  headers: Schema3.Record(Schema3.String, Schema3.String),
+  data: Schema3.NullOr(Schema3.Unknown),
+  error: Schema3.NullOr(Schema3.Unknown)
+});
+
 // src/sdk/extract.ts
-import { Effect as Effect2, Option as Option2 } from "effect";
+import { Effect as Effect2, Option } from "effect";
 var HTTP_METHODS = [
   "get",
   "put",
@@ -315,11 +302,11 @@ var extractParameters = (pathItem, operation, r) => {
       name: p.name,
       location: p.in,
       required: p.in === "path" ? true : p.required === true,
-      schema: Option2.fromNullishOr(p.schema),
-      style: Option2.fromNullishOr(p.style),
-      explode: Option2.fromNullishOr(p.explode),
-      allowReserved: Option2.fromNullishOr("allowReserved" in p ? p.allowReserved : void 0),
-      description: Option2.fromNullishOr(p.description)
+      schema: Option.fromNullishOr(p.schema),
+      style: Option.fromNullishOr(p.style),
+      explode: Option.fromNullishOr(p.explode),
+      allowReserved: Option.fromNullishOr("allowReserved" in p ? p.allowReserved : void 0),
+      description: Option.fromNullishOr(p.description)
     })
   );
 };
@@ -330,10 +317,10 @@ var buildEncodingRecord = (encoding) => {
     if (typeof raw !== "object" || raw === null) continue;
     const e = raw;
     out[prop] = EncodingObject.make({
-      contentType: Option2.fromNullishOr(e.contentType),
-      style: Option2.fromNullishOr(e.style),
-      explode: Option2.fromNullishOr(e.explode),
-      allowReserved: Option2.fromNullishOr(e.allowReserved)
+      contentType: Option.fromNullishOr(e.contentType),
+      style: Option.fromNullishOr(e.style),
+      explode: Option.fromNullishOr(e.explode),
+      allowReserved: Option.fromNullishOr(e.allowReserved)
     });
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -345,8 +332,8 @@ var extractRequestBody = (operation, r) => {
   const contents = declaredContents(body.content).map(
     ({ mediaType, media }) => MediaBinding.make({
       contentType: mediaType,
-      schema: Option2.fromNullishOr(media.schema),
-      encoding: Option2.fromNullishOr(
+      schema: Option.fromNullishOr(media.schema),
+      encoding: Option.fromNullishOr(
         buildEncodingRecord(media.encoding)
       )
     })
@@ -357,7 +344,7 @@ var extractRequestBody = (operation, r) => {
     required: body.required === true,
     contentType: defaultContent.contentType,
     schema: defaultContent.schema,
-    contents: Option2.some(contents)
+    contents: Option.some(contents)
   });
 };
 var extractOutputSchema = (operation, r) => {
@@ -375,17 +362,63 @@ var extractOutputSchema = (operation, r) => {
   }
   return void 0;
 };
-var buildInputSchema = (parameters, requestBody) => {
+var buildServerInputProperty = (servers) => {
+  const variableDefs = {};
+  for (const server of servers) {
+    for (const [name, v] of Object.entries(Option.getOrUndefined(server.variables) ?? {})) {
+      if (!(name in variableDefs)) variableDefs[name] = v;
+    }
+  }
+  const hasMultiple = servers.length > 1;
+  const variableNames = Object.keys(variableDefs);
+  if (!hasMultiple && variableNames.length === 0) return void 0;
+  const properties = {};
+  if (hasMultiple) {
+    properties.url = {
+      type: "string",
+      enum: servers.map((server) => server.url),
+      default: servers[0].url,
+      description: "Which of the spec's servers to send the request to."
+    };
+  }
+  if (variableNames.length > 0) {
+    properties.variables = {
+      type: "object",
+      additionalProperties: false,
+      properties: Object.fromEntries(
+        Object.entries(variableDefs).map(([name, v]) => [
+          name,
+          {
+            type: "string",
+            default: v.default,
+            ...Option.isSome(v.enum) ? { enum: v.enum.value } : {},
+            ...Option.isSome(v.description) ? { description: v.description.value } : {}
+          }
+        ])
+      ),
+      description: "Values for the server URL `{variables}`; spec defaults apply when omitted."
+    };
+  }
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    description: "Optional host selection and server-URL variables for this request."
+  };
+};
+var buildInputSchema = (parameters, requestBody, servers) => {
   const properties = {};
   const required = [];
   for (const param of parameters) {
-    properties[param.name] = Option2.getOrElse(param.schema, () => ({ type: "string" }));
+    properties[param.name] = Option.getOrElse(param.schema, () => ({ type: "string" }));
     if (param.required) required.push(param.name);
   }
+  const serverProperty = buildServerInputProperty(servers);
+  if (serverProperty && !("server" in properties)) properties.server = serverProperty;
   if (requestBody) {
-    properties.body = Option2.getOrElse(requestBody.schema, () => ({ type: "object" }));
+    properties.body = Option.getOrElse(requestBody.schema, () => ({ type: "object" }));
     if (requestBody.required) required.push("body");
-    const contents = Option2.getOrUndefined(requestBody.contents);
+    const contents = Option.getOrUndefined(requestBody.contents);
     if (contents && contents.length > 1) {
       properties.contentType = {
         type: "string",
@@ -424,8 +457,8 @@ var extractServerList = (servers) => (servers ?? []).flatMap((server) => {
           name,
           ServerVariable.make({
             default: String(v.default),
-            enum: enumValues && enumValues.length > 0 ? Option2.some(enumValues) : Option2.none(),
-            description: Option2.fromNullishOr(v.description)
+            enum: enumValues && enumValues.length > 0 ? Option.some(enumValues) : Option.none(),
+            description: Option.fromNullishOr(v.description)
           })
         ]
       ];
@@ -434,18 +467,18 @@ var extractServerList = (servers) => (servers ?? []).flatMap((server) => {
   return [
     ServerInfo.make({
       url: server.url,
-      description: Option2.fromNullishOr(server.description),
-      variables: vars && Object.keys(vars).length > 0 ? Option2.some(vars) : Option2.none()
+      description: Option.fromNullishOr(server.description),
+      variables: vars && Object.keys(vars).length > 0 ? Option.some(vars) : Option.none()
     })
   ];
 });
 var extractServers = (doc) => extractServerList(doc.servers);
-var extractOperationBaseUrl = (pathItem, operation) => {
-  const operationServers = extractServerList(operation.servers);
-  if (operationServers.length > 0) return resolveBaseUrl(operationServers);
-  const pathServers = extractServerList(pathItem.servers);
-  if (pathServers.length > 0) return resolveBaseUrl(pathServers);
-  return void 0;
+var operationServers = (pathItem, operation, docServers) => {
+  const operationLevel = extractServerList(operation.servers);
+  if (operationLevel.length > 0) return operationLevel;
+  const pathLevel = extractServerList(pathItem.servers);
+  if (pathLevel.length > 0) return pathLevel;
+  return docServers;
 };
 var extract = Effect2.fn("OpenApi.extract")(function* (doc) {
   const paths = doc.paths;
@@ -455,6 +488,7 @@ var extract = Effect2.fn("OpenApi.extract")(function* (doc) {
     });
   }
   const r = new DocResolver(doc);
+  const docServers = extractServers(doc);
   const operations = [];
   for (const [pathTemplate, pathItem] of Object.entries(paths).sort(
     ([a], [b]) => a.localeCompare(b)
@@ -465,39 +499,40 @@ var extract = Effect2.fn("OpenApi.extract")(function* (doc) {
       if (!operation) continue;
       const parameters = extractParameters(pathItem, operation, r);
       const requestBody = extractRequestBody(operation, r);
-      const inputSchema = buildInputSchema(parameters, requestBody);
+      const servers = operationServers(pathItem, operation, docServers);
+      const inputSchema = buildInputSchema(parameters, requestBody, servers);
       const outputSchema = extractOutputSchema(operation, r);
       const tags = (operation.tags ?? []).filter((t) => t.trim().length > 0);
       const operationPathTemplate = explicitPathTemplate(operation) ?? pathTemplate;
       operations.push(
         ExtractedOperation.make({
           operationId: OperationId.make(deriveOperationId(method, pathTemplate, operation)),
-          toolPath: Option2.fromNullishOr(explicitToolPath(operation)),
+          toolPath: Option.fromNullishOr(explicitToolPath(operation)),
           method,
-          baseUrl: extractOperationBaseUrl(pathItem, operation),
+          servers,
           pathTemplate: operationPathTemplate,
-          summary: Option2.fromNullishOr(operation.summary),
-          description: Option2.fromNullishOr(operation.description),
+          summary: Option.fromNullishOr(operation.summary),
+          description: Option.fromNullishOr(operation.description),
           tags,
           parameters,
-          requestBody: Option2.fromNullishOr(requestBody),
-          inputSchema: Option2.fromNullishOr(inputSchema),
-          outputSchema: Option2.fromNullishOr(outputSchema),
+          requestBody: Option.fromNullishOr(requestBody),
+          inputSchema: Option.fromNullishOr(inputSchema),
+          outputSchema: Option.fromNullishOr(outputSchema),
           deprecated: operation.deprecated === true
         })
       );
     }
   }
   return ExtractionResult.make({
-    title: Option2.fromNullishOr(doc.info?.title),
-    version: Option2.fromNullishOr(doc.info?.version),
-    servers: extractServers(doc),
+    title: Option.fromNullishOr(doc.info?.title),
+    version: Option.fromNullishOr(doc.info?.version),
+    servers: docServers,
     operations
   });
 });
 
 // src/sdk/preview.ts
-import { Effect as Effect3, Option as Option3, Predicate } from "effect";
+import { Effect as Effect3, Option as Option2, Predicate } from "effect";
 import { Schema as Schema4 } from "effect";
 var OAuth2Scopes = Schema4.Record(Schema4.String, Schema4.String);
 var SecuritySchemeType = Schema4.Literals(["http", "apiKey", "oauth2", "openIdConnect"]);
@@ -604,21 +639,21 @@ var stringRecord = (value) => {
   return out;
 };
 var extractFlows = (rawFlows) => {
-  if (!rawFlows || typeof rawFlows !== "object") return Option3.none();
+  if (!rawFlows || typeof rawFlows !== "object") return Option2.none();
   const flows = rawFlows;
   const parseFlow = (key) => flows[key];
-  let authorizationCode = Option3.none();
+  let authorizationCode = Option2.none();
   const authCodeRaw = parseFlow("authorizationCode");
   if (authCodeRaw && typeof authCodeRaw === "object") {
     const f = authCodeRaw;
     const authUrl = typeof f.authorizationUrl === "string" ? f.authorizationUrl : null;
     const tokenUrl = typeof f.tokenUrl === "string" ? f.tokenUrl : null;
     if (authUrl && tokenUrl) {
-      authorizationCode = Option3.some(
+      authorizationCode = Option2.some(
         OAuth2AuthorizationCodeFlow.make({
           authorizationUrl: authUrl,
           tokenUrl,
-          refreshUrl: Option3.fromNullishOr(
+          refreshUrl: Option2.fromNullishOr(
             typeof f.refreshUrl === "string" ? f.refreshUrl : void 0
           ),
           scopes: stringRecord(f.scopes)
@@ -626,16 +661,16 @@ var extractFlows = (rawFlows) => {
       );
     }
   }
-  let clientCredentials = Option3.none();
+  let clientCredentials = Option2.none();
   const ccRaw = parseFlow("clientCredentials");
   if (ccRaw && typeof ccRaw === "object") {
     const f = ccRaw;
     const tokenUrl = typeof f.tokenUrl === "string" ? f.tokenUrl : null;
     if (tokenUrl) {
-      clientCredentials = Option3.some(
+      clientCredentials = Option2.some(
         OAuth2ClientCredentialsFlow.make({
           tokenUrl,
-          refreshUrl: Option3.fromNullishOr(
+          refreshUrl: Option2.fromNullishOr(
             typeof f.refreshUrl === "string" ? f.refreshUrl : void 0
           ),
           scopes: stringRecord(f.scopes)
@@ -643,10 +678,10 @@ var extractFlows = (rawFlows) => {
       );
     }
   }
-  if (Option3.isNone(authorizationCode) && Option3.isNone(clientCredentials)) {
-    return Option3.none();
+  if (Option2.isNone(authorizationCode) && Option2.isNone(clientCredentials)) {
+    return Option2.none();
   }
-  return Option3.some(OAuth2Flows.make({ authorizationCode, clientCredentials }));
+  return Option2.some(OAuth2Flows.make({ authorizationCode, clientCredentials }));
 };
 var extractSecuritySchemes = (rawSchemes, resolver) => Object.entries(rawSchemes).flatMap(([name, schemeOrRef]) => {
   if (!schemeOrRef || typeof schemeOrRef !== "object") return [];
@@ -656,19 +691,19 @@ var extractSecuritySchemes = (rawSchemes, resolver) => Object.entries(rawSchemes
   if (!resolved || typeof resolved !== "object") return [];
   const scheme = resolved;
   const type = decodeSecuritySchemeType(scheme.type);
-  if (Option3.isNone(type)) return [];
+  if (Option2.isNone(type)) return [];
   const schemeType = type.value;
   return [
     SecurityScheme.make({
       name,
       type: schemeType,
-      scheme: Option3.fromNullishOr(scheme.scheme),
-      bearerFormat: Option3.fromNullishOr(scheme.bearerFormat),
-      in: Option3.fromNullishOr(scheme.in),
-      headerName: Option3.fromNullishOr(scheme.name),
-      description: Option3.fromNullishOr(scheme.description),
-      flows: schemeType === "oauth2" ? extractFlows(scheme.flows) : Option3.none(),
-      openIdConnectUrl: Option3.fromNullishOr(scheme.openIdConnectUrl)
+      scheme: Option2.fromNullishOr(scheme.scheme),
+      bearerFormat: Option2.fromNullishOr(scheme.bearerFormat),
+      in: Option2.fromNullishOr(scheme.in),
+      headerName: Option2.fromNullishOr(scheme.name),
+      description: Option2.fromNullishOr(scheme.description),
+      flows: schemeType === "oauth2" ? extractFlows(scheme.flows) : Option2.none(),
+      openIdConnectUrl: Option2.fromNullishOr(scheme.openIdConnectUrl)
     })
   ];
 });
@@ -681,21 +716,21 @@ var buildHeaderPresets = (schemes, strategies) => {
     const secretHeaders = [];
     const labelParts = [];
     for (const scheme of resolved) {
-      if (scheme.type === "http" && Option3.getOrElse(scheme.scheme, () => "") === "bearer") {
+      if (scheme.type === "http" && Option2.getOrElse(scheme.scheme, () => "") === "bearer") {
         headers["Authorization"] = null;
         secretHeaders.push("Authorization");
         labelParts.push("Bearer Token");
-      } else if (scheme.type === "http" && Option3.getOrElse(scheme.scheme, () => "") === "basic") {
+      } else if (scheme.type === "http" && Option2.getOrElse(scheme.scheme, () => "") === "basic") {
         headers["Authorization"] = null;
         secretHeaders.push("Authorization");
         labelParts.push("Basic Auth");
-      } else if (scheme.type === "apiKey" && Option3.getOrElse(scheme.in, () => "") === "header") {
-        const headerName = Option3.getOrElse(scheme.headerName, () => scheme.name);
+      } else if (scheme.type === "apiKey" && Option2.getOrElse(scheme.in, () => "") === "header") {
+        const headerName = Option2.getOrElse(scheme.headerName, () => scheme.name);
         headers[headerName] = null;
         secretHeaders.push(headerName);
         labelParts.push(scheme.name);
       } else if (scheme.type === "apiKey") {
-        labelParts.push(`${scheme.name} (${Option3.getOrElse(scheme.in, () => "unknown")})`);
+        labelParts.push(`${scheme.name} (${Option2.getOrElse(scheme.in, () => "unknown")})`);
       } else if (scheme.type === "oauth2" || scheme.type === "openIdConnect") {
         return [];
       } else {
@@ -724,16 +759,16 @@ var buildOAuth2Presets = (schemes) => {
   const presets = [];
   for (const scheme of schemes) {
     if (scheme.type !== "oauth2") continue;
-    if (Option3.isNone(scheme.flows)) continue;
+    if (Option2.isNone(scheme.flows)) continue;
     const flows = scheme.flows.value;
-    if (Option3.isSome(flows.authorizationCode)) {
+    if (Option2.isSome(flows.authorizationCode)) {
       const flow = flows.authorizationCode.value;
       presets.push(
         OAuth2Preset.make({
           label: `OAuth2 Authorization Code \xB7 ${scheme.name}`,
           securitySchemeName: scheme.name,
           flow: "authorizationCode",
-          authorizationUrl: Option3.some(flow.authorizationUrl),
+          authorizationUrl: Option2.some(flow.authorizationUrl),
           tokenUrl: flow.tokenUrl,
           refreshUrl: flow.refreshUrl,
           scopes: flow.scopes,
@@ -741,14 +776,14 @@ var buildOAuth2Presets = (schemes) => {
         })
       );
     }
-    if (Option3.isSome(flows.clientCredentials)) {
+    if (Option2.isSome(flows.clientCredentials)) {
       const flow = flows.clientCredentials.value;
       presets.push(
         OAuth2Preset.make({
           label: `OAuth2 Client Credentials \xB7 ${scheme.name}`,
           securitySchemeName: scheme.name,
           flow: "clientCredentials",
-          authorizationUrl: Option3.none(),
+          authorizationUrl: Option2.none(),
           tokenUrl: flow.tokenUrl,
           refreshUrl: flow.refreshUrl,
           scopes: flow.scopes,
@@ -766,8 +801,7 @@ var collectTags = (result) => {
   }
   return [...tagSet].sort();
 };
-var previewSpec = Effect3.fn("OpenApi.previewSpec")(function* (input) {
-  const specText = yield* resolveSpecText(input);
+var previewSpecText = Effect3.fn("OpenApi.previewSpecText")(function* (specText) {
   const doc = yield* parse(specText);
   const result = yield* extract(doc);
   const resolver = new DocResolver(doc);
@@ -799,10 +833,25 @@ var previewSpec = Effect3.fn("OpenApi.previewSpec")(function* (input) {
     oauth2Presets: buildOAuth2Presets(securitySchemes)
   });
 });
+var previewSpec = Effect3.fn("OpenApi.previewSpec")(function* (input) {
+  const specText = yield* resolveSpecText(input);
+  return yield* previewSpecText(specText);
+});
 
 export {
-  variable,
-  TOKEN_VARIABLE,
+  OpenApiParseError,
+  OpenApiExtractionError,
+  OpenApiInvocationError,
+  OpenApiOAuthError,
+  OpenApiAuthRequiredError,
+  fetchSpecText,
+  resolveSpecText,
+  parse,
+  DocResolver,
+  substituteUrlVariables,
+  resolveServerUrl,
+  preferredContent,
+  normalizeOpenApiAuthInputs,
   OperationId,
   HttpMethod,
   ParameterLocation,
@@ -810,25 +859,13 @@ export {
   EncodingObject,
   MediaBinding,
   OperationRequestBody,
-  ExtractedOperation,
   ServerVariable,
   ServerInfo,
+  ExtractedOperation,
   ExtractionResult,
   OperationBinding,
   InvocationResult,
-  OpenApiParseError,
-  OpenApiExtractionError,
-  OpenApiInvocationError,
-  OpenApiOAuthError,
-  OpenApiAuthRequiredError,
-  fetchSpecText,
-  resolveSpecText,
-  parse,
-  DocResolver,
-  substituteUrlVariables,
-  expandServerUrlOptions,
-  resolveBaseUrl,
-  preferredContent,
+  TOKEN_VARIABLE,
   extract,
   OAuth2AuthorizationCodeFlow,
   OAuth2ClientCredentialsFlow,
@@ -839,6 +876,7 @@ export {
   OAuth2Preset,
   PreviewOperation,
   SpecPreview,
+  previewSpecText,
   previewSpec
 };
-//# sourceMappingURL=chunk-YVRI7KRC.js.map
+//# sourceMappingURL=chunk-C3IJX4AN.js.map