@executor-js/plugin-openapi 1.5.15 → 1.5.16

package/dist/react/client.d.ts

@@ -14,14 +14,6 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
         }>>>;
     }>>;
     readonly operationCount: import("effect/Schema").Number;
-    readonly operations: import("effect/Schema").$Array<import("effect/Schema").Struct<{
-        readonly operationId: import("effect/Schema").String;
-        readonly method: import("effect/Schema").Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
-        readonly path: import("effect/Schema").String;
-        readonly summary: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
-        readonly tags: import("effect/Schema").$Array<import("effect/Schema").String>;
-        readonly deprecated: import("effect/Schema").Boolean;
-    }>>;
     readonly tags: import("effect/Schema").$Array<import("effect/Schema").String>;
     readonly securitySchemes: import("effect/Schema").$Array<import("effect/Schema").Struct<{
         readonly name: import("effect/Schema").String;
@@ -71,12 +63,6 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
     }>, import("effect/Schema").Struct<{
         readonly kind: import("effect/Schema").Literal<"blob">;
         readonly value: import("effect/Schema").String;
-    }>, import("effect/Schema").Struct<{
-        readonly kind: import("effect/Schema").Literal<"googleDiscovery">;
-        readonly url: import("effect/Schema").String;
-    }>, import("effect/Schema").Struct<{
-        readonly kind: import("effect/Schema").Literal<"googleDiscoveryBundle">;
-        readonly urls: import("effect/Schema").$Array<import("effect/Schema").String>;
     }>]>;
     readonly slug: import("effect/Schema").String;
     readonly name: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -118,7 +104,6 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
     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 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>;
     readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
     readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
@@ -191,12 +176,6 @@ export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpA
     }>, import("effect/Schema").Struct<{
         readonly kind: import("effect/Schema").Literal<"blob">;
         readonly value: import("effect/Schema").String;
-    }>, import("effect/Schema").Struct<{
-        readonly kind: import("effect/Schema").Literal<"googleDiscovery">;
-        readonly url: import("effect/Schema").String;
-    }>, import("effect/Schema").Struct<{
-        readonly kind: import("effect/Schema").Literal<"googleDiscoveryBundle">;
-        readonly urls: 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">;

package/dist/react/index.d.ts

@@ -1,3 +1,5 @@
 export { openApiIntegrationPlugin } from "./source-plugin";
 export { OpenApiClient } from "./client";
+export { OpenApiSourceDetailsFields } from "./OpenApiSourceDetailsFields";
+export { authenticationFromEditorValue, authMethodsFromConfig, editorValueFromAuthentication, openApiWireAuthInput, placementsFromApiKey, templateFromPlacements, } from "./auth-method-config";
 export { previewOpenApiSpec, addOpenApiSpec, removeOpenApiSpec, openapiConfigure, openApiConfigAtom, openApiConfigFamily, openApiIntegrationAtom, openApiIntegrationFamily, } from "./atoms";

package/dist/sdk/backing.d.ts

@@ -0,0 +1,54 @@
+import { Effect } from "effect";
+import type { Layer } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { type PluginCtx, type ResolveToolsResult, type StorageFailure, type ToolDef, type ToolInvocationCredential } from "@executor-js/sdk/core";
+import { type OpenApiIntegrationConfig } from "./config";
+import { OpenApiExtractionError, OpenApiParseError } from "./errors";
+import { type ToolDefinition } from "./definitions";
+import { type ParsedDocument } from "./parse";
+import { type OpenapiStore, type StoredOperation } from "./store";
+export declare const extractOpenApiUpstreamMessage: (body: unknown, status: number) => string;
+/** Rewrite OpenAPI `#/components/schemas/X` refs to standard `#/$defs/X`. */
+export declare const normalizeOpenApiRefs: (node: unknown) => unknown;
+export interface CompiledOpenApiSpec {
+    readonly definitions: readonly ToolDefinition[];
+    readonly hoistedDefs: Record<string, unknown>;
+    readonly title: string | undefined;
+    readonly description: string | undefined;
+}
+export declare const compileOpenApiDocument: (doc: ParsedDocument) => Effect.Effect<CompiledOpenApiSpec, OpenApiExtractionError>;
+export declare const compileOpenApiSpec: (specText: string) => Effect.Effect<CompiledOpenApiSpec, OpenApiParseError | OpenApiExtractionError>;
+export declare const openApiToolDefsFromCompiled: (compiled: CompiledOpenApiSpec) => readonly ToolDef[];
+export declare const openApiStoredOperationsFromCompiled: (integration: string, compiled: CompiledOpenApiSpec) => readonly StoredOperation[];
+export declare const loadOpenApiSpecText: (storage: OpenapiStore, config: OpenApiIntegrationConfig) => Effect.Effect<string | null, StorageFailure>;
+export declare const resolveOpenApiBackedTools: ({ config, storage, }: {
+    readonly config: unknown;
+    readonly storage: OpenapiStore;
+}) => Effect.Effect<ResolveToolsResult, StorageFailure>;
+export declare const invokeOpenApiBackedTool: (input: {
+    readonly ctx: PluginCtx<OpenapiStore>;
+    readonly toolRow: {
+        readonly integration: string;
+        readonly name: string;
+    };
+    readonly credential: ToolInvocationCredential;
+    readonly args: unknown;
+    readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>;
+}) => Effect.Effect<{
+    readonly ok: false;
+    readonly error: import("@executor-js/sdk/core").ToolError;
+} | {
+    readonly ok: true;
+    readonly data: unknown;
+    readonly http?: import("@executor-js/sdk/core").ToolHttpMeta;
+}, StorageFailure | OpenApiExtractionError | import("./errors").OpenApiInvocationError, never>;
+export declare const resolveOpenApiBackedAnnotations: (input: {
+    readonly ctx: PluginCtx<OpenapiStore>;
+    readonly integration: string;
+    readonly toolRows: readonly {
+        readonly name: string;
+    }[];
+}) => Effect.Effect<Record<string, {
+    requiresApproval?: boolean;
+    approvalDescription?: string;
+}>, StorageFailure, never>;

package/dist/sdk/config.d.ts

@@ -24,8 +24,6 @@ export declare const OpenApiIntegrationConfigSchema: Schema.Struct<{
     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>>;
     /** Optional base URL override. */
     readonly baseUrl: Schema.optional<Schema.String>;
     /** Static headers applied to every request (no secret material). */

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

@@ -1,9 +1,11 @@
-import type { HeaderPreset, OAuth2Preset, SpecPreview } from "./preview";
+import type { HeaderPreset, OAuth2Preset, SpecPreview, SpecPreviewSummary } from "./preview";
 import type { Authentication } from "./types";
+type PreviewAuthMetadata = SpecPreview | SpecPreviewSummary;
 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;
+export declare const firstBaseUrlForPreview: (preview: PreviewAuthMetadata) => 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[];
+export declare const deriveAuthenticationTemplateFromPreview: (preview: PreviewAuthMetadata, baseUrl: string | undefined) => readonly Authentication[];
+export {};

package/dist/sdk/index.d.ts

@@ -1,7 +1,8 @@
 export { parse, resolveSpecText, fetchSpecText } from "./parse";
-export { convertGoogleDiscoveryBundleToOpenApi, convertGoogleDiscoveryToOpenApi, fetchGoogleDiscoveryDocument, isGoogleDiscoveryUrl, type GoogleDiscoveryOpenApiConversion, } from "./google-discovery";
 export { extract } from "./extract";
 export { invoke, invokeWithLayer, annotationsForOperation } from "./invoke";
+export { compileOpenApiDocument, compileOpenApiSpec, extractOpenApiUpstreamMessage, invokeOpenApiBackedTool, loadOpenApiSpecText, normalizeOpenApiRefs, openApiStoredOperationsFromCompiled, openApiToolDefsFromCompiled, resolveOpenApiBackedAnnotations, resolveOpenApiBackedTools, type CompiledOpenApiSpec, } from "./backing";
+export type { ParsedDocument } from "./parse";
 export { openApiPlugin, type OpenApiSpecConfig, type OpenApiConfigureInput, type OpenApiSpecInput, type OpenApiPreviewInput, type OpenApiPluginExtension, type OpenApiPluginOptions, } from "./plugin";
 export { type OpenapiStore, type StoredOperation, makeDefaultOpenapiStore } from "./store";
 export { decodeOpenApiIntegrationConfig, renderAuthTemplate, AuthenticationSchema, OpenApiIntegrationConfigSchema, type OpenApiIntegrationConfig, type RenderedAuth, } from "./config";

package/dist/sdk/plugin.d.ts

@@ -29,7 +29,7 @@ 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 — canonical
+    /** Auth methods a connection's value renders through - canonical
      *  placements or the request-shaped authoring dialect. */
     readonly authenticationTemplate?: readonly AuthenticationInput[];
 }
@@ -47,7 +47,7 @@ export interface OpenApiConfigureInput {
     readonly mode?: "merge" | "replace";
 }
 /** What changed in the tool catalog when a spec was updated in place. Tool
- *  names, not addresses — the same diff applies to every connection. */
+ *  names, not addresses - the same diff applies to every connection. */
 export interface UpdateSpecResult {
     readonly slug: IntegrationSlug;
     readonly toolCount: number;
@@ -56,7 +56,7 @@ export interface UpdateSpecResult {
 }
 export interface OpenApiUpdateSpecInput {
     /** New spec source. Omit to re-fetch from the integration's stored
-     *  `sourceUrl` / Google Discovery bundle URLs. */
+     *  `sourceUrl`. */
     readonly spec?: OpenApiSpecInput;
 }
 export interface OpenApiPluginExtension {
@@ -66,7 +66,7 @@ export interface OpenApiPluginExtension {
         readonly toolCount: number;
     }, OpenApiParseError | OpenApiExtractionError | OpenApiOAuthError | IntegrationAlreadyExistsError | StorageFailure>;
     /** Re-resolve the integration's spec (from its stored source URL, or the
-     *  provided input) and rebuild its tools IN PLACE — connections,
+     *  provided input) and rebuild its tools IN PLACE - connections,
      *  credentials, policies, and the curated description are untouched. */
     readonly updateSpec: (slug: string, input?: OpenApiUpdateSpecInput) => Effect.Effect<UpdateSpecResult, OpenApiParseError | OpenApiExtractionError | OpenApiOAuthError | IntegrationNotFoundError | StorageFailure>;
     readonly removeSpec: (slug: string) => Effect.Effect<void, StorageFailure>;
@@ -84,12 +84,6 @@ declare const OpenApiSpecInputSchema: Schema.Union<readonly [Schema.Struct<{
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"blob">;
     readonly value: Schema.String;
-}>, Schema.Struct<{
-    readonly kind: Schema.Literal<"googleDiscovery">;
-    readonly url: Schema.String;
-}>, Schema.Struct<{
-    readonly kind: Schema.Literal<"googleDiscoveryBundle">;
-    readonly urls: Schema.$Array<Schema.String>;
 }>]>;
 export declare const describeOpenApiAuthMethods: (record: IntegrationRecord) => readonly AuthMethodDescriptor[];
 export declare const describeOpenApiIntegrationDisplay: (record: IntegrationRecord) => {

package/dist/sdk/presets.d.ts

@@ -6,5 +6,4 @@ export interface OpenApiPreset {
     readonly icon?: string;
     readonly featured?: boolean;
 }
-export { googleOpenApiPresets, googleStandardUserOAuthPresets } from "./google-presets";
 export declare const openApiPresets: readonly OpenApiPreset[];

package/dist/sdk/preview.d.ts

@@ -193,6 +193,85 @@ export declare const SpecPreview: Schema.Struct<{
     }>>;
 }>;
 export type SpecPreview = typeof SpecPreview.Type;
+export declare const SpecPreviewSummary: Schema.Struct<{
+    readonly title: Schema.OptionFromOptional<Schema.String>;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+    readonly version: Schema.OptionFromOptional<Schema.String>;
+    readonly servers: Schema.$Array<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly description: Schema.OptionFromOptional<Schema.String>;
+        readonly variables: Schema.OptionFromOptional<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly default: Schema.String;
+            readonly enum: Schema.OptionFromOptional<Schema.$Array<Schema.String>>;
+            readonly description: Schema.OptionFromOptional<Schema.String>;
+        }>>>;
+    }>>;
+    readonly operationCount: Schema.Number;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly securitySchemes: Schema.$Array<Schema.Struct<{
+        /** Key name in components.securitySchemes (e.g. "api_token") */
+        readonly name: Schema.String;
+        /** OpenAPI security scheme type */
+        readonly type: Schema.Literals<readonly ["http", "apiKey", "oauth2", "openIdConnect"]>;
+        /** For type: "http" — e.g. "bearer", "basic" */
+        readonly scheme: Schema.OptionFromOptional<Schema.String>;
+        /** For type: "http" with scheme "bearer" — e.g. "JWT" */
+        readonly bearerFormat: Schema.OptionFromOptional<Schema.String>;
+        /** For type: "apiKey" — where the key goes */
+        readonly in: Schema.OptionFromOptional<Schema.Literals<readonly ["header", "query", "cookie"]>>;
+        /** For type: "apiKey" — the header/query/cookie name */
+        readonly headerName: Schema.OptionFromOptional<Schema.String>;
+        readonly description: Schema.OptionFromOptional<Schema.String>;
+        /** For type: "oauth2" — declared flows (authorizationCode / clientCredentials only; implicit and password are deprecated). */
+        readonly flows: Schema.OptionFromOptional<Schema.Struct<{
+            readonly authorizationCode: Schema.OptionFromOptional<Schema.Struct<{
+                readonly authorizationUrl: Schema.String;
+                readonly tokenUrl: Schema.String;
+                readonly refreshUrl: Schema.OptionFromOptional<Schema.String>;
+                readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+            }>>;
+            readonly clientCredentials: Schema.OptionFromOptional<Schema.Struct<{
+                readonly tokenUrl: Schema.String;
+                readonly refreshUrl: Schema.OptionFromOptional<Schema.String>;
+                readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+            }>>;
+        }>>;
+        /** For type: "openIdConnect" — the discovery URL. */
+        readonly openIdConnectUrl: Schema.OptionFromOptional<Schema.String>;
+    }>>;
+    readonly authStrategies: Schema.$Array<Schema.Struct<{
+        /** The security schemes required together for this strategy */
+        readonly schemes: Schema.$Array<Schema.String>;
+    }>>;
+    readonly headerPresets: Schema.$Array<Schema.Struct<{
+        /** Human-readable label for the UI (e.g. "Bearer Token", "API Key + Email") */
+        readonly label: Schema.String;
+        /** Headers this strategy needs. Value is null when the user must provide it. */
+        readonly headers: Schema.$Record<Schema.String, Schema.NullOr<Schema.String>>;
+        /** Which headers should be stored as secrets */
+        readonly secretHeaders: Schema.$Array<Schema.String>;
+    }>>;
+    readonly oauth2Presets: Schema.$Array<Schema.Struct<{
+        /** Human-readable label for the UI (e.g. "OAuth2 (Authorization Code) — oauth_app") */
+        readonly label: Schema.String;
+        /** The source security scheme this preset came from (components.securitySchemes key). */
+        readonly securitySchemeName: Schema.String;
+        /** Which OAuth2 flow this preset uses. */
+        readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
+        /** For authorizationCode: user-agent redirect URL (from the spec). */
+        readonly authorizationUrl: Schema.OptionFromOptional<Schema.String>;
+        /** Token endpoint to exchange the code / refresh. */
+        readonly tokenUrl: Schema.String;
+        /** Optional refresh endpoint if the spec declares one separately. */
+        readonly refreshUrl: Schema.OptionFromOptional<Schema.String>;
+        /** Declared scopes for this flow: `{ scope: description }`. */
+        readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+        /** Identity scopes to request alongside API scopes. `"auto"` discovers standard OIDC scopes. */
+        readonly identityScopes: Schema.Union<readonly [Schema.Literal<"auto">, Schema.Literal<false>, Schema.$Array<Schema.String>]>;
+    }>>;
+}>;
+export type SpecPreviewSummary = typeof SpecPreviewSummary.Type;
+export declare const specPreviewSummary: (preview: SpecPreview) => SpecPreviewSummary;
 /** Preview already-resolved spec text — extract metadata without registering
  *  anything and without any HTTP dependency. */
 export declare const previewSpecText: (specText: string) => Effect.Effect<{

package/dist/testing/index.d.ts

@@ -129,12 +129,6 @@ export declare const makeOpenApiHttpApiTestAddSpecPayload: (api: HttpApi.Any, op
     } | {
         readonly value: string;
         readonly kind: "blob";
-    } | {
-        readonly kind: "googleDiscovery";
-        readonly url: string;
-    } | {
-        readonly kind: "googleDiscoveryBundle";
-        readonly urls: readonly string[];
     };
     slug: string;
     baseUrl: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executor-js/plugin-openapi",
-  "version": "1.5.15",
+  "version": "1.5.16",
   "homepage": "https://github.com/RhysSullivan/executor/tree/main/packages/plugins/openapi",
   "bugs": {
     "url": "https://github.com/RhysSullivan/executor/issues"
@@ -53,15 +53,16 @@
   },
   "dependencies": {
     "@effect/platform-node": "4.0.0-beta.59",
-    "@executor-js/config": "1.5.15",
-    "@executor-js/sdk": "1.5.15",
+    "@executor-js/config": "1.5.16",
+    "@executor-js/sdk": "1.5.16",
+    "js-yaml": "4.1.1",
     "lucide-react": "^1.7.0",
-    "openapi-types": "^12.1.3",
-    "yaml": "^2.7.1"
+    "openapi-types": "^12.1.3"
   },
   "devDependencies": {
     "@effect/atom-react": "4.0.0-beta.59",
     "@effect/vitest": "4.0.0-beta.59",
+    "@types/js-yaml": "4.0.9",
     "@types/node": "^24.3.1",
     "@types/react": "^19.1.0",
     "bun-types": "^1.2.22",