@executor-js/plugin-openapi 1.5.6 → 1.5.7

package/dist/react/OpenApiSourceDetailsFields.d.ts

@@ -7,6 +7,9 @@ export declare function OpenApiSourceDetailsFields(props: {
     readonly baseUrl: string;
     readonly onBaseUrlChange: (value: string) => void;
     readonly baseUrlOptions?: readonly FreeformComboboxOption[];
+    readonly baseUrlLabel?: string;
+    readonly baseUrlPlaceholder?: string;
+    readonly baseUrlHint?: string;
     readonly specUrl?: string;
     readonly onSpecUrlChange?: (value: string) => void;
     readonly faviconIcon?: string | null;

package/dist/react/atoms.d.ts

@@ -8,34 +8,29 @@ export declare const openApiIntegrationAtom: (slug: IntegrationSlug) => Atom.Ato
     readonly canRefresh: boolean;
 } | null, import("@executor-js/sdk").IntegrationAlreadyExistsError | import("@executor-js/sdk").InternalError | import("../sdk").OpenApiParseError | import("../sdk").OpenApiExtractionError | import("../sdk").OpenApiOAuthError>>;
 export declare const openApiConfigAtom: (slug: IntegrationSlug) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
-    readonly spec: string;
     readonly headers?: {
         readonly [x: string]: string;
     } | undefined;
-    readonly baseUrl?: string | undefined;
     readonly queryParams?: {
         readonly [x: string]: string;
     } | undefined;
     readonly sourceUrl?: string | undefined;
     readonly googleDiscoveryUrls?: readonly string[] | undefined;
+    readonly baseUrl?: string | undefined;
     readonly authenticationTemplate?: readonly ({
-        readonly type: "apiKey";
         readonly slug: string;
-        readonly headers?: {
-            readonly [x: string]: string | readonly (string | {
-                readonly name: string;
-                readonly type: "variable";
-            })[];
-        } | undefined;
-        readonly queryParams?: {
-            readonly [x: string]: string | readonly (string | {
-                readonly name: string;
-                readonly type: "variable";
-            })[];
-        } | undefined;
+        readonly kind: "apikey";
+        readonly placements: readonly {
+            readonly name: string;
+            readonly carrier: "header" | "query";
+            readonly variable?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly literal?: string | undefined;
+        }[];
+        readonly label?: string | undefined;
     } | {
-        readonly type: "oauth";
         readonly slug: string;
+        readonly kind: "oauth2";
         readonly authorizationUrl: string;
         readonly tokenUrl: string;
         readonly scopes: readonly string[];
@@ -58,7 +53,6 @@ export declare const previewOpenApiSpec: Atom.AtomResultFn<{
         readonly operationId: string;
     }[];
     readonly title: import("effect/Option").Option<string>;
-    readonly tags: readonly string[];
     readonly servers: readonly {
         readonly description: import("effect/Option").Option<string>;
         readonly url: string;
@@ -70,6 +64,7 @@ export declare const previewOpenApiSpec: Atom.AtomResultFn<{
             };
         }>;
     }[];
+    readonly tags: readonly string[];
     readonly securitySchemes: readonly {
         readonly name: string;
         readonly type: "oauth2" | "http" | "apiKey" | "openIdConnect";
@@ -141,13 +136,14 @@ export declare const addOpenApiSpec: Atom.AtomResultFn<{
         readonly headers?: {
             readonly [x: string]: string;
         } | undefined;
-        readonly baseUrl?: string | undefined;
         readonly queryParams?: {
             readonly [x: string]: string;
         } | undefined;
+        readonly baseUrl?: string | undefined;
         readonly authenticationTemplate?: readonly ({
             readonly type: "apiKey";
-            readonly slug: string;
+            readonly slug?: string | undefined;
+            readonly label?: string | undefined;
             readonly headers?: {
                 readonly [x: string]: string | readonly (string | {
                     readonly name: string;
@@ -161,8 +157,8 @@ export declare const addOpenApiSpec: Atom.AtomResultFn<{
                 })[];
             } | undefined;
         } | {
-            readonly type: "oauth";
             readonly slug: string;
+            readonly kind: "oauth2";
             readonly authorizationUrl: string;
             readonly tokenUrl: string;
             readonly scopes: readonly string[];
@@ -188,7 +184,8 @@ export declare const openapiConfigure: Atom.AtomResultFn<{
     readonly payload: {
         readonly authenticationTemplate: readonly ({
             readonly type: "apiKey";
-            readonly slug: string;
+            readonly slug?: string | undefined;
+            readonly label?: string | undefined;
             readonly headers?: {
                 readonly [x: string]: string | readonly (string | {
                     readonly name: string;
@@ -202,8 +199,8 @@ export declare const openapiConfigure: Atom.AtomResultFn<{
                 })[];
             } | undefined;
         } | {
-            readonly type: "oauth";
             readonly slug: string;
+            readonly kind: "oauth2";
             readonly authorizationUrl: string;
             readonly tokenUrl: string;
             readonly scopes: readonly string[];
@@ -214,23 +211,19 @@ export declare const openapiConfigure: Atom.AtomResultFn<{
     readonly reactivityKeys?: readonly unknown[] | import("effect/Record").ReadonlyRecord<string, readonly unknown[]> | undefined;
 }, {
     readonly authenticationTemplate: readonly ({
-        readonly type: "apiKey";
         readonly slug: string;
-        readonly headers?: {
-            readonly [x: string]: string | readonly (string | {
-                readonly name: string;
-                readonly type: "variable";
-            })[];
-        } | undefined;
-        readonly queryParams?: {
-            readonly [x: string]: string | readonly (string | {
-                readonly name: string;
-                readonly type: "variable";
-            })[];
-        } | undefined;
+        readonly kind: "apikey";
+        readonly placements: readonly {
+            readonly name: string;
+            readonly carrier: "header" | "query";
+            readonly variable?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly literal?: string | undefined;
+        }[];
+        readonly label?: string | undefined;
     } | {
-        readonly type: "oauth";
         readonly slug: string;
+        readonly kind: "oauth2";
         readonly authorizationUrl: string;
         readonly tokenUrl: string;
         readonly scopes: readonly string[];
@@ -244,34 +237,29 @@ export declare const openApiIntegrationFamily: (arg: string & import("effect/Bra
     readonly canRefresh: boolean;
 } | null, import("@executor-js/sdk").IntegrationAlreadyExistsError | import("@executor-js/sdk").InternalError | import("../sdk").OpenApiParseError | import("../sdk").OpenApiExtractionError | import("../sdk").OpenApiOAuthError>>;
 export declare const openApiConfigFamily: (arg: string & import("effect/Brand").Brand<"IntegrationSlug">) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
-    readonly spec: string;
     readonly headers?: {
         readonly [x: string]: string;
     } | undefined;
-    readonly baseUrl?: string | undefined;
     readonly queryParams?: {
         readonly [x: string]: string;
     } | undefined;
     readonly sourceUrl?: string | undefined;
     readonly googleDiscoveryUrls?: readonly string[] | undefined;
+    readonly baseUrl?: string | undefined;
     readonly authenticationTemplate?: readonly ({
-        readonly type: "apiKey";
         readonly slug: string;
-        readonly headers?: {
-            readonly [x: string]: string | readonly (string | {
-                readonly name: string;
-                readonly type: "variable";
-            })[];
-        } | undefined;
-        readonly queryParams?: {
-            readonly [x: string]: string | readonly (string | {
-                readonly name: string;
-                readonly type: "variable";
-            })[];
-        } | undefined;
+        readonly kind: "apikey";
+        readonly placements: readonly {
+            readonly name: string;
+            readonly carrier: "header" | "query";
+            readonly variable?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly literal?: string | undefined;
+        }[];
+        readonly label?: string | undefined;
     } | {
-        readonly type: "oauth";
         readonly slug: string;
+        readonly kind: "oauth2";
         readonly authorizationUrl: string;
         readonly tokenUrl: string;
         readonly scopes: readonly string[];

package/dist/react/auth-method-config.d.ts

@@ -1,11 +1,14 @@
 import type { AuthMethod, Placement } from "@executor-js/react/lib/auth-placements";
 import type { AuthTemplateEditorValue } from "@executor-js/react/components/auth-template-editor";
-import { type APIKeyAuthentication, type Authentication } from "../sdk/types";
-export declare const placementsFromApiKey: (template: APIKeyAuthentication) => Placement[];
+import type { APIKeyAuthentication, Authentication, AuthenticationInput } from "../sdk/types";
+/** Serialize a canonical method into the wire input union (apikey → the
+ *  request-shaped dialect; oauth passes through). */
+export declare const openApiWireAuthInput: (method: Authentication) => AuthenticationInput;
+export declare const placementsFromApiKey: (template: APIKeyAuthentication) => readonly Placement[];
 /** Map each stored auth template to a generic `AuthMethod`. */
 export declare function authMethodsFromConfig(templates: readonly Authentication[]): AuthMethod[];
-/** Build an `APIKeyAuthentication` template from generic placements. When
- *  `slug` is omitted the backend assigns a `custom_<id>` slug. */
+/** Build an apikey method from generic placements. When `slug` is omitted the
+ *  backend assigns a `custom_<id>` slug. */
 export declare function templateFromPlacements(placements: readonly Placement[], slug?: string): APIKeyAuthentication;
 /** Convert one stored `Authentication` template into a generic editor value. */
 export declare function editorValueFromAuthentication(template: Authentication): AuthTemplateEditorValue;

package/dist/react/client.d.ts

@@ -84,7 +84,14 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
     readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
     readonly authenticationTemplate: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
         readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly authorizationUrl: import("effect/Schema").String;
+        readonly tokenUrl: import("effect/Schema").String;
+        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly type: import("effect/Schema").Literal<"apiKey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Literal<"variable">;
             readonly name: import("effect/Schema").String;
@@ -93,12 +100,6 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
             readonly type: import("effect/Schema").Literal<"variable">;
             readonly name: import("effect/Schema").String;
         }>]>>]>>>;
-    }>, import("effect/Schema").Struct<{
-        readonly slug: import("effect/Schema").String;
-        readonly type: import("effect/Schema").Literal<"oauth">;
-        readonly authorizationUrl: import("effect/Schema").String;
-        readonly tokenUrl: import("effect/Schema").String;
-        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
     }>]>>>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
@@ -114,7 +115,6 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
 }>>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/sdk").IntegrationAlreadyExistsError | typeof import("@executor-js/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getConfig", "GET", "/openapi/integrations/:slug/config", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     slug: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
-    readonly spec: import("effect/Schema").String;
     readonly sourceUrl: import("effect/Schema").optional<import("effect/Schema").String>;
     readonly googleDiscoveryUrls: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
     readonly baseUrl: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -122,28 +122,35 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
     readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
     readonly authenticationTemplate: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
         readonly slug: import("effect/Schema").String;
-        readonly type: import("effect/Schema").Literal<"apiKey">;
-        readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
-            readonly type: import("effect/Schema").Literal<"variable">;
-            readonly name: import("effect/Schema").String;
-        }>]>>]>>>;
-        readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
-            readonly type: import("effect/Schema").Literal<"variable">;
-            readonly name: import("effect/Schema").String;
-        }>]>>]>>>;
-    }>, import("effect/Schema").Struct<{
-        readonly slug: import("effect/Schema").String;
-        readonly type: import("effect/Schema").Literal<"oauth">;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
         readonly authorizationUrl: import("effect/Schema").String;
         readonly tokenUrl: import("effect/Schema").String;
         readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"apikey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+            readonly name: import("effect/Schema").String;
+            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>>;
     }>]>>>;
 }>>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/sdk").IntegrationAlreadyExistsError | typeof import("@executor-js/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"configure", "POST", "/openapi/integrations/:slug/config", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     slug: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
         readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly authorizationUrl: import("effect/Schema").String;
+        readonly tokenUrl: import("effect/Schema").String;
+        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly type: import("effect/Schema").Literal<"apiKey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Literal<"variable">;
             readonly name: import("effect/Schema").String;
@@ -152,32 +159,26 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
             readonly type: import("effect/Schema").Literal<"variable">;
             readonly name: import("effect/Schema").String;
         }>]>>]>>>;
-    }>, import("effect/Schema").Struct<{
-        readonly slug: import("effect/Schema").String;
-        readonly type: import("effect/Schema").Literal<"oauth">;
-        readonly authorizationUrl: import("effect/Schema").String;
-        readonly tokenUrl: import("effect/Schema").String;
-        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
     }>]>>;
     readonly mode: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["merge", "replace"]>>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
         readonly slug: import("effect/Schema").String;
-        readonly type: import("effect/Schema").Literal<"apiKey">;
-        readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
-            readonly type: import("effect/Schema").Literal<"variable">;
-            readonly name: import("effect/Schema").String;
-        }>]>>]>>>;
-        readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
-            readonly type: import("effect/Schema").Literal<"variable">;
-            readonly name: import("effect/Schema").String;
-        }>]>>]>>>;
-    }>, import("effect/Schema").Struct<{
-        readonly slug: import("effect/Schema").String;
-        readonly type: import("effect/Schema").Literal<"oauth">;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
         readonly authorizationUrl: import("effect/Schema").String;
         readonly tokenUrl: import("effect/Schema").String;
         readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"apikey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+            readonly name: import("effect/Schema").String;
+            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>>;
     }>]>>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/sdk").IntegrationAlreadyExistsError | typeof import("@executor-js/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"removeSpec", "DELETE", "/openapi/integrations/:slug", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     slug: import("effect/Schema").String;

package/dist/sdk/config.d.ts

@@ -2,30 +2,31 @@ import { Schema } from "effect";
 import type { Authentication } from "./types";
 export declare const AuthenticationSchema: Schema.Union<readonly [Schema.Struct<{
     readonly slug: Schema.String;
-    readonly type: Schema.Literal<"oauth">;
+    readonly kind: Schema.Literal<"oauth2">;
     readonly authorizationUrl: Schema.String;
     readonly tokenUrl: Schema.String;
     readonly scopes: Schema.$Array<Schema.String>;
 }>, Schema.Struct<{
     readonly slug: Schema.String;
-    readonly type: Schema.Literal<"apiKey">;
-    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly type: Schema.Literal<"variable">;
+    readonly kind: Schema.Literal<"apikey">;
+    readonly label: Schema.optional<Schema.String>;
+    readonly placements: Schema.$Array<Schema.Struct<{
+        readonly carrier: Schema.Literals<readonly ["header", "query"]>;
         readonly name: Schema.String;
-    }>]>>]>>>;
-    readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly type: Schema.Literal<"variable">;
-        readonly name: Schema.String;
-    }>]>>]>>>;
+        readonly prefix: Schema.optional<Schema.String>;
+        readonly variable: Schema.optional<Schema.String>;
+        readonly literal: Schema.optional<Schema.String>;
+    }>>;
 }>]>;
 export declare const OpenApiIntegrationConfigSchema: Schema.Struct<{
-    /** Inlined OpenAPI document text (resolved + parsed source of truth). */
-    readonly spec: Schema.String;
+    /** Hex SHA-256 of the resolved spec text — the content address of the spec
+     *  blob (`spec/<hash>` in the plugin blob store). */
+    readonly specHash: Schema.optional<Schema.String>;
     /** Origin URL the spec was fetched from, when known. Enables refresh. */
     readonly sourceUrl: Schema.optional<Schema.String>;
     /** Google Discovery bundle URLs, when the spec came from a Google bundle. */
     readonly googleDiscoveryUrls: Schema.optional<Schema.$Array<Schema.String>>;
-    /** Base URL override; falls back to the spec's first server. */
+    /** Optional base URL override. */
     readonly baseUrl: Schema.optional<Schema.String>;
     /** Static headers applied to every request (no secret material). */
     readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
@@ -34,21 +35,21 @@ export declare const OpenApiIntegrationConfigSchema: Schema.Struct<{
     /** The auth methods a connection's value can be applied through. */
     readonly authenticationTemplate: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly slug: Schema.String;
-        readonly type: Schema.Literal<"oauth">;
+        readonly kind: Schema.Literal<"oauth2">;
         readonly authorizationUrl: Schema.String;
         readonly tokenUrl: Schema.String;
         readonly scopes: Schema.$Array<Schema.String>;
     }>, Schema.Struct<{
         readonly slug: Schema.String;
-        readonly type: Schema.Literal<"apiKey">;
-        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
-            readonly type: Schema.Literal<"variable">;
-            readonly name: Schema.String;
-        }>]>>]>>>;
-        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
-            readonly type: Schema.Literal<"variable">;
+        readonly kind: Schema.Literal<"apikey">;
+        readonly label: Schema.optional<Schema.String>;
+        readonly placements: Schema.$Array<Schema.Struct<{
+            readonly carrier: Schema.Literals<readonly ["header", "query"]>;
             readonly name: Schema.String;
-        }>]>>]>>>;
+            readonly prefix: Schema.optional<Schema.String>;
+            readonly variable: Schema.optional<Schema.String>;
+            readonly literal: Schema.optional<Schema.String>;
+        }>>;
     }>]>>>;
 }>;
 export type OpenApiIntegrationConfig = Omit<typeof OpenApiIntegrationConfigSchema.Type, "authenticationTemplate"> & {
@@ -64,12 +65,11 @@ export interface RenderedAuth {
     readonly queryParams: Record<string, string>;
 }
 /** Render an auth template against a connection's resolved input `values`
- *  (`variable → value`). For an apiKey template, each `variable("<name>")` is
- *  substituted from its own entry, so a method with two distinct inputs (e.g.
- *  Datadog) fills each header from a different value. For an oauth template (no
- *  explicit placement), render a bearer Authorization header from `token`. */
+ *  (`variable → value`). Each placement substitutes from its own entry, so a
+ *  method with two distinct inputs (e.g. Datadog) fills each header from a
+ *  different value. */
 export declare const renderAuthTemplate: (template: Authentication, values: Record<string, string | null>) => RenderedAuth;
 /** The distinct input variables a template references — the inputs a connection
- *  must supply. An oauth template needs `token`; an apiKey template needs every
- *  `variable("<name>")` across its placements. */
+ *  must supply. An oauth template needs `token`; an apiKey method needs every
+ *  variable across its placements. */
 export declare const requiredTemplateVariables: (template: Authentication) => readonly string[];

package/dist/sdk/derive-auth.d.ts

@@ -0,0 +1,9 @@
+import type { HeaderPreset, OAuth2Preset, SpecPreview } from "./preview";
+import type { Authentication } from "./types";
+export declare function resolveOAuthUrl(url: string, baseUrl: string): string;
+export declare const resolvedOAuthScopes: (apiScopes: Iterable<string>, identityScopes: OAuth2Preset["identityScopes"]) => string[];
+export declare const detectedAuthenticationTemplates: (headerPresets: readonly HeaderPreset[], oauth2Presets: readonly OAuth2Preset[], baseUrl: string) => readonly Authentication[];
+export declare const firstBaseUrlForPreview: (preview: SpecPreview) => string;
+/** The fallback `addSpec` uses when no explicit template was passed: every
+ *  spec-detected method, resolved against the integration's base URL. */
+export declare const deriveAuthenticationTemplateFromPreview: (preview: SpecPreview, baseUrl: string | undefined) => readonly Authentication[];

package/dist/sdk/extract.d.ts

@@ -11,6 +11,17 @@ export declare const extract: (doc: ParsedDocument) => Effect.Effect<{
         readonly method: "post" | "options" | "delete" | "get" | "put" | "patch" | "head" | "trace";
         readonly deprecated: boolean;
         readonly toolPath: Option.Option<string>;
+        readonly servers: readonly {
+            readonly description: Option.Option<string>;
+            readonly url: string;
+            readonly variables: Option.Option<{
+                readonly [x: string]: {
+                    readonly default: string;
+                    readonly description: Option.Option<string>;
+                    readonly enum: Option.Option<readonly string[]>;
+                };
+            }>;
+        }[];
         readonly summary: Option.Option<string>;
         readonly tags: readonly string[];
         readonly parameters: readonly {
@@ -42,7 +53,6 @@ export declare const extract: (doc: ParsedDocument) => Effect.Effect<{
         }>;
         readonly operationId: string & import("effect/Brand").Brand<"OperationId">;
         readonly pathTemplate: string;
-        readonly baseUrl?: string | undefined;
     }[];
     readonly title: Option.Option<string>;
     readonly servers: readonly {

package/dist/sdk/index.d.ts

@@ -6,6 +6,10 @@ export { openApiPlugin, type OpenApiSpecConfig, type OpenApiConfigureInput, type
 export { type OpenapiStore, type StoredOperation, makeDefaultOpenapiStore } from "./store";
 export { decodeOpenApiIntegrationConfig, renderAuthTemplate, AuthenticationSchema, OpenApiIntegrationConfigSchema, type OpenApiIntegrationConfig, type RenderedAuth, } from "./config";
 export { previewSpec, SecurityScheme, AuthStrategy, HeaderPreset, OAuth2Preset, OAuth2Flows, OAuth2AuthorizationCodeFlow, OAuth2ClientCredentialsFlow, PreviewOperation, SpecPreview, } from "./preview";
-export { DocResolver, resolveBaseUrl, substituteUrlVariables, preferredContent, } from "./openapi-utils";
+export { DocResolver, resolveServerUrl, substituteUrlVariables, preferredContent, } from "./openapi-utils";
 export { OpenApiParseError, OpenApiExtractionError, OpenApiInvocationError, OpenApiOAuthError, OpenApiAuthRequiredError, } from "./errors";
-export { EncodingObject, ExtractedOperation, ExtractionResult, InvocationResult, MediaBinding, OperationBinding, OperationParameter, OperationRequestBody, ServerInfo, ServerVariable, OperationId, HttpMethod, ParameterLocation, variable, type Authentication, type APIKeyAuthentication, type AuthenticationVariable, type AuthenticationTemplateValue, } from "./types";
+export { EncodingObject, ExtractedOperation, ExtractionResult, InvocationResult, MediaBinding, OperationBinding, OperationParameter, OperationRequestBody, ServerInfo, ServerVariable, OperationId, HttpMethod, ParameterLocation, TOKEN_VARIABLE, normalizeOpenApiAuthInputs, type Authentication, type AuthenticationInput, type APIKeyAuthentication, } from "./types";
+export { variable, type ApiKeyAuthTemplate } from "@executor-js/sdk/http-auth";
+export { migrateOpenApiAuthConfig } from "./migrate-config";
+export { openApiOutputSchemaDataMigration, runSqliteOpenApiOutputSchemaMigration, unwrapOpenApiTransportEnvelope, } from "./output-schema-migration";
+export { openApiSpecBlobDataMigration } from "./spec-blob-migration";

package/dist/sdk/invoke.d.ts

@@ -32,7 +32,17 @@ export declare const invoke: (operation: {
         }[]>;
     }>;
     readonly pathTemplate: string;
-    readonly baseUrl?: string | undefined;
+    readonly servers?: readonly {
+        readonly description: Option.Option<string>;
+        readonly url: string;
+        readonly variables: Option.Option<{
+            readonly [x: string]: {
+                readonly default: string;
+                readonly description: Option.Option<string>;
+                readonly enum: Option.Option<readonly string[]>;
+            };
+        }>;
+    }[] | undefined;
 }, args: Record<string, unknown>, resolvedHeaders: Record<string, string>, sourceQueryParams?: Record<string, string> | undefined) => Effect.Effect<{
     readonly error: unknown;
     readonly data: unknown;

package/dist/sdk/migrate-config.d.ts

@@ -0,0 +1,4 @@
+/** Rewrite a stored OpenAPI integration config blob into the canonical shape.
+ *  Returns the rewritten config, or `null` when no rewrite is needed (already
+ *  canonical, no auth templates, or not this plugin's shape). Idempotent. */
+export declare const migrateOpenApiAuthConfig: (config: unknown) => unknown | null;

package/dist/sdk/migrate-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/openapi-utils.d.ts

@@ -17,13 +17,10 @@ export declare class DocResolver {
 }
 /** Substitute `{var}` placeholders in a templated URL using a plain map. */
 export declare const substituteUrlVariables: (url: string, values: Record<string, string>) => string;
-export declare const OPENAPI_MAX_SERVER_VARIABLE_OPTIONS = 64;
-type ServerLike = {
-    url: string;
-    variables: import("effect/Option").Option<Record<string, ServerVariable | string>>;
-};
-export declare const expandServerUrlOptions: (server: ServerLike, limit?: number) => readonly string[];
-export declare const resolveBaseUrl: (servers: readonly ServerLike[]) => string;
+/** Resolve a templated server URL, filling each `{var}` from `overrides` when
+ *  non-empty, otherwise the variable's spec default. URLs without placeholders
+ *  pass through unchanged. */
+export declare const resolveServerUrl: (templateUrl: string, variables: Record<string, ServerVariable> | undefined, overrides: Record<string, string>) => string;
 /**
  * Return all declared media entries in spec order. `Object.entries` on a
  * plain object preserves insertion order in modern engines, which matches
@@ -54,4 +51,3 @@ export declare const preferredResponseContent: (content: Record<string, MediaTyp
     mediaType: string;
     media: MediaTypeObject;
 } | undefined;
-export {};

package/dist/sdk/output-schema-migration.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { DataMigrationError, type SqliteDataMigrationClient } from "@executor-js/sdk/core";
+/**
+ * If `schema` is the retired transport envelope, return the payload schema
+ * to persist instead (`null` when the envelope carried an empty `{}` data
+ * schema — the new producer persists no output schema for those). Returns
+ * undefined when the schema is not an envelope and the row must be left
+ * untouched.
+ */
+export declare const unwrapOpenApiTransportEnvelope: (schema: unknown) => {
+    readonly outputSchema: unknown | null;
+} | undefined;
+/** Unwrap envelope-shaped openapi tool output schemas in a SQLite database.
+ *  Returns the number of rows rewritten. The `tool` table may not exist yet
+ *  on a fresh database — that counts as nothing to migrate. */
+export declare const runSqliteOpenApiOutputSchemaMigration: (client: SqliteDataMigrationClient) => Effect.Effect<number, DataMigrationError>;
+/** Registry entry for the boot-time data-migration ledger. */
+export declare const openApiOutputSchemaDataMigration: {
+    name: string;
+    run: (client: SqliteDataMigrationClient) => Effect.Effect<void, DataMigrationError, never>;
+};

package/dist/sdk/output-schema-migration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/plugin.d.ts

@@ -7,6 +7,7 @@ import { OpenApiExtractionError, OpenApiOAuthError, OpenApiParseError } from "./
 import { type SpecPreview } from "./preview";
 import { type OpenapiStore } from "./store";
 import type { Authentication } from "./types";
+import { type AuthenticationInput } from "./types";
 export type OpenApiSpecInput = typeof OpenApiSpecInputSchema.Type;
 export interface OpenApiPreviewInput {
     readonly spec: string;
@@ -25,8 +26,9 @@ export interface OpenApiSpecConfig {
     readonly headers?: Record<string, string>;
     /** Static query params applied to every request. */
     readonly queryParams?: Record<string, string>;
-    /** Auth methods a connection's value renders through. */
-    readonly authenticationTemplate?: readonly Authentication[];
+    /** Auth methods a connection's value renders through — canonical
+     *  placements or the request-shaped authoring dialect. */
+    readonly authenticationTemplate?: readonly AuthenticationInput[];
 }
 export interface OpenApiExtensionFailure {
     readonly _tag: string;
@@ -38,7 +40,7 @@ export interface OpenApiConfigureInput {
      *  already exists, replaces) the integration's existing template array. A
      *  custom apiKey method with no `slug` is assigned a generated `custom_<id>`
      *  slug that is collision-checked against the existing template. */
-    readonly authenticationTemplate: readonly Authentication[];
+    readonly authenticationTemplate: readonly AuthenticationInput[];
     readonly mode?: "merge" | "replace";
 }
 export interface OpenApiPluginExtension {
@@ -88,7 +90,6 @@ export declare const openApiPlugin: import("@executor-js/sdk/core").ConfiguredPl
             readonly operationId: string;
         }[];
         readonly title: Option.Option<string>;
-        readonly tags: readonly string[];
         readonly servers: readonly {
             readonly description: Option.Option<string>;
             readonly url: string;
@@ -100,6 +101,7 @@ export declare const openApiPlugin: import("@executor-js/sdk/core").ConfiguredPl
                 };
             }>;
         }[];
+        readonly tags: readonly string[];
         readonly securitySchemes: readonly {
             readonly name: string;
             readonly type: "oauth2" | "http" | "apiKey" | "openIdConnect";