@executor-js/plugin-openapi 0.1.0 → 1.4.20

package/dist/sdk/types.d.ts

@@ -5,7 +5,7 @@ export declare const HttpMethod: Schema.Literals<readonly ["get", "put", "post",
 export type HttpMethod = typeof HttpMethod.Type;
 export declare const ParameterLocation: Schema.Literals<readonly ["path", "query", "header", "cookie"]>;
 export type ParameterLocation = typeof ParameterLocation.Type;
-declare const OperationParameter_base: Schema.Class<OperationParameter, Schema.Struct<{
+export declare const OperationParameter: Schema.Struct<{
     readonly name: Schema.String;
     readonly location: Schema.Literals<readonly ["path", "query", "header", "cookie"]>;
     readonly required: Schema.Boolean;
@@ -14,15 +14,8 @@ declare const OperationParameter_base: Schema.Class<OperationParameter, Schema.S
     readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
     readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
     readonly description: Schema.OptionFromOptional<Schema.String>;
-}>, {}>;
-export declare class OperationParameter extends OperationParameter_base {
-}
-declare const EncodingObject_base: Schema.Class<EncodingObject, Schema.Struct<{
-    readonly contentType: Schema.OptionFromOptional<Schema.String>;
-    readonly style: Schema.OptionFromOptional<Schema.String>;
-    readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
-    readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
-}>, {}>;
+}>;
+export type OperationParameter = typeof OperationParameter.Type;
 /**
  * OpenAPI 3.x `Encoding Object` (§4.8.15). Declared per-property inside a
  * multipart/form-data or application/x-www-form-urlencoded request body.
@@ -32,16 +25,25 @@ declare const EncodingObject_base: Schema.Class<EncodingObject, Schema.Struct<{
  * - `style` / `explode` / `allowReserved` — for form-urlencoded, control
  *   array / object serialization the same way parameter-level style does.
  */
-export declare class EncodingObject extends EncodingObject_base {
-}
-declare const MediaBinding_base: Schema.Class<MediaBinding, Schema.Struct<{
+export declare const EncodingObject: Schema.Struct<{
+    readonly contentType: Schema.OptionFromOptional<Schema.String>;
+    readonly style: Schema.OptionFromOptional<Schema.String>;
+    readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+    readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+}>;
+export type EncodingObject = typeof EncodingObject.Type;
+export declare const MediaBinding: Schema.Struct<{
     readonly contentType: Schema.String;
     readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
-    readonly encoding: Schema.OptionFromOptional<Schema.$Record<Schema.String, typeof EncodingObject>>;
-}>, {}>;
-export declare class MediaBinding extends MediaBinding_base {
-}
-declare const OperationRequestBody_base: Schema.Class<OperationRequestBody, Schema.Struct<{
+    readonly encoding: Schema.OptionFromOptional<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly contentType: Schema.OptionFromOptional<Schema.String>;
+        readonly style: Schema.OptionFromOptional<Schema.String>;
+        readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+        readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+    }>>>;
+}>;
+export type MediaBinding = typeof MediaBinding.Type;
+export declare const OperationRequestBody: Schema.Struct<{
     readonly 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. */
@@ -52,55 +54,172 @@ declare const OperationRequestBody_base: Schema.Class<OperationRequestBody, Sche
     /** 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}`. */
-    readonly contents: Schema.OptionFromOptional<Schema.$Array<typeof MediaBinding>>;
-}>, {}>;
-export declare class OperationRequestBody extends OperationRequestBody_base {
-}
-declare const ExtractedOperation_base: Schema.Class<ExtractedOperation, Schema.Struct<{
+    readonly contents: Schema.OptionFromOptional<Schema.$Array<Schema.Struct<{
+        readonly contentType: Schema.String;
+        readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+        readonly encoding: Schema.OptionFromOptional<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly contentType: Schema.OptionFromOptional<Schema.String>;
+            readonly style: Schema.OptionFromOptional<Schema.String>;
+            readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+            readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+        }>>>;
+    }>>>;
+}>;
+export type OperationRequestBody = typeof OperationRequestBody.Type;
+export declare const ExtractedOperation: Schema.Struct<{
     readonly operationId: Schema.brand<Schema.String, "OperationId">;
     readonly method: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
     readonly pathTemplate: Schema.String;
     readonly summary: Schema.OptionFromOptional<Schema.String>;
     readonly description: Schema.OptionFromOptional<Schema.String>;
     readonly tags: Schema.$Array<Schema.String>;
-    readonly parameters: Schema.$Array<typeof OperationParameter>;
-    readonly requestBody: Schema.OptionFromOptional<typeof OperationRequestBody>;
+    readonly parameters: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly location: Schema.Literals<readonly ["path", "query", "header", "cookie"]>;
+        readonly required: Schema.Boolean;
+        readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+        readonly style: Schema.OptionFromOptional<Schema.String>;
+        readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+        readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+        readonly description: Schema.OptionFromOptional<Schema.String>;
+    }>>;
+    readonly requestBody: Schema.OptionFromOptional<Schema.Struct<{
+        readonly 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. */
+        readonly contentType: Schema.String;
+        /** Schema of the default media type. Kept for backward compat with stored
+         *  bindings from before `contents` was added. */
+        readonly 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}`. */
+        readonly contents: Schema.OptionFromOptional<Schema.$Array<Schema.Struct<{
+            readonly contentType: Schema.String;
+            readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+            readonly encoding: Schema.OptionFromOptional<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly contentType: Schema.OptionFromOptional<Schema.String>;
+                readonly style: Schema.OptionFromOptional<Schema.String>;
+                readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+                readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+            }>>>;
+        }>>>;
+    }>>;
     readonly inputSchema: Schema.OptionFromOptional<Schema.Unknown>;
     readonly outputSchema: Schema.OptionFromOptional<Schema.Unknown>;
     readonly deprecated: Schema.Boolean;
-}>, {}>;
-export declare class ExtractedOperation extends ExtractedOperation_base {
-}
-declare const ServerVariable_base: Schema.Class<ServerVariable, Schema.Struct<{
+}>;
+export type ExtractedOperation = typeof ExtractedOperation.Type;
+export declare const ServerVariable: Schema.Struct<{
     readonly default: Schema.String;
     readonly enum: Schema.OptionFromOptional<Schema.$Array<Schema.String>>;
     readonly description: Schema.OptionFromOptional<Schema.String>;
-}>, {}>;
-export declare class ServerVariable extends ServerVariable_base {
-}
-declare const ServerInfo_base: Schema.Class<ServerInfo, Schema.Struct<{
+}>;
+export type ServerVariable = typeof ServerVariable.Type;
+export declare const ServerInfo: Schema.Struct<{
     readonly url: Schema.String;
     readonly description: Schema.OptionFromOptional<Schema.String>;
-    readonly variables: Schema.OptionFromOptional<Schema.$Record<Schema.String, typeof ServerVariable>>;
-}>, {}>;
-export declare class ServerInfo extends ServerInfo_base {
-}
-declare const ExtractionResult_base: Schema.Class<ExtractionResult, Schema.Struct<{
+    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>;
+    }>>>;
+}>;
+export type ServerInfo = typeof ServerInfo.Type;
+export declare const ExtractionResult: Schema.Struct<{
     readonly title: Schema.OptionFromOptional<Schema.String>;
     readonly version: Schema.OptionFromOptional<Schema.String>;
-    readonly servers: Schema.$Array<typeof ServerInfo>;
-    readonly operations: Schema.$Array<typeof ExtractedOperation>;
-}>, {}>;
-export declare class ExtractionResult extends ExtractionResult_base {
-}
-declare const OperationBinding_base: Schema.Class<OperationBinding, Schema.Struct<{
+    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 operations: Schema.$Array<Schema.Struct<{
+        readonly operationId: Schema.brand<Schema.String, "OperationId">;
+        readonly method: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
+        readonly pathTemplate: Schema.String;
+        readonly summary: Schema.OptionFromOptional<Schema.String>;
+        readonly description: Schema.OptionFromOptional<Schema.String>;
+        readonly tags: Schema.$Array<Schema.String>;
+        readonly parameters: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly location: Schema.Literals<readonly ["path", "query", "header", "cookie"]>;
+            readonly required: Schema.Boolean;
+            readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+            readonly style: Schema.OptionFromOptional<Schema.String>;
+            readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+            readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+            readonly description: Schema.OptionFromOptional<Schema.String>;
+        }>>;
+        readonly requestBody: Schema.OptionFromOptional<Schema.Struct<{
+            readonly 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. */
+            readonly contentType: Schema.String;
+            /** Schema of the default media type. Kept for backward compat with stored
+             *  bindings from before `contents` was added. */
+            readonly 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}`. */
+            readonly contents: Schema.OptionFromOptional<Schema.$Array<Schema.Struct<{
+                readonly contentType: Schema.String;
+                readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+                readonly encoding: Schema.OptionFromOptional<Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly contentType: Schema.OptionFromOptional<Schema.String>;
+                    readonly style: Schema.OptionFromOptional<Schema.String>;
+                    readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+                    readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+                }>>>;
+            }>>>;
+        }>>;
+        readonly inputSchema: Schema.OptionFromOptional<Schema.Unknown>;
+        readonly outputSchema: Schema.OptionFromOptional<Schema.Unknown>;
+        readonly deprecated: Schema.Boolean;
+    }>>;
+}>;
+export type ExtractionResult = typeof ExtractionResult.Type;
+export declare const OperationBinding: Schema.Struct<{
     readonly method: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
     readonly pathTemplate: Schema.String;
-    readonly parameters: Schema.$Array<typeof OperationParameter>;
-    readonly requestBody: Schema.OptionFromOptional<typeof OperationRequestBody>;
-}>, {}>;
-export declare class OperationBinding extends OperationBinding_base {
-}
+    readonly parameters: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly location: Schema.Literals<readonly ["path", "query", "header", "cookie"]>;
+        readonly required: Schema.Boolean;
+        readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+        readonly style: Schema.OptionFromOptional<Schema.String>;
+        readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+        readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+        readonly description: Schema.OptionFromOptional<Schema.String>;
+    }>>;
+    readonly requestBody: Schema.OptionFromOptional<Schema.Struct<{
+        readonly 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. */
+        readonly contentType: Schema.String;
+        /** Schema of the default media type. Kept for backward compat with stored
+         *  bindings from before `contents` was added. */
+        readonly 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}`. */
+        readonly contents: Schema.OptionFromOptional<Schema.$Array<Schema.Struct<{
+            readonly contentType: Schema.String;
+            readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+            readonly encoding: Schema.OptionFromOptional<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly contentType: Schema.OptionFromOptional<Schema.String>;
+                readonly style: Schema.OptionFromOptional<Schema.String>;
+                readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+                readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+            }>>>;
+        }>>>;
+    }>>;
+}>;
+export type OperationBinding = typeof OperationBinding.Type;
 /**
  * A header value — either a static string or a reference to a secret.
  * Stored as JSON-serializable data.
@@ -110,18 +229,36 @@ export declare const HeaderValue: Schema.Union<readonly [Schema.String, Schema.S
     readonly prefix: Schema.optional<Schema.String>;
 }>]>;
 export type HeaderValue = typeof HeaderValue.Type;
-declare const ConfiguredHeaderBinding_base: Schema.Class<ConfiguredHeaderBinding, Schema.Struct<{
+export declare const ConfiguredHeaderBinding: Schema.Struct<{
+    readonly kind: Schema.Literal<"binding">;
+    readonly slot: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>;
+export type ConfiguredHeaderBinding = typeof ConfiguredHeaderBinding.Type;
+export declare const ConfiguredHeaderValue: Schema.Union<readonly [Schema.String, Schema.Struct<{
     readonly kind: Schema.Literal<"binding">;
     readonly slot: Schema.String;
     readonly prefix: Schema.optional<Schema.String>;
-}>, {}>;
-export declare class ConfiguredHeaderBinding extends ConfiguredHeaderBinding_base {
-}
-export declare const ConfiguredHeaderValue: Schema.Union<readonly [Schema.String, typeof ConfiguredHeaderBinding]>;
+}>]>;
 export type ConfiguredHeaderValue = typeof ConfiguredHeaderValue.Type;
+export declare const OpenApiCredentialInput: Schema.Union<readonly [Schema.Struct<{
+    readonly secretId: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+    readonly targetScope: Schema.brand<Schema.String, "ScopeId">;
+    readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
+}>, Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly secretId: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>]>, Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly kind: Schema.Literal<"binding">;
+    readonly slot: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>]>]>;
+export type OpenApiCredentialInput = typeof OpenApiCredentialInput.Type;
 export declare const OpenApiSourceBindingValue: Schema.Union<readonly [Schema.Struct<{
     readonly kind: Schema.Literal<"secret">;
     readonly secretId: Schema.brand<Schema.String, "SecretId">;
+    readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"connection">;
     readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
@@ -130,7 +267,7 @@ export declare const OpenApiSourceBindingValue: Schema.Union<readonly [Schema.St
     readonly text: Schema.String;
 }>]>;
 export type OpenApiSourceBindingValue = typeof OpenApiSourceBindingValue.Type;
-export declare const OpenApiSourceBindingInputSchema: Schema.Struct<{
+export declare const OpenApiSourceBindingInput: Schema.Struct<{
     readonly sourceId: Schema.String;
     readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
     readonly scope: Schema.brand<Schema.String, "ScopeId">;
@@ -138,6 +275,7 @@ export declare const OpenApiSourceBindingInputSchema: Schema.Struct<{
     readonly value: Schema.Union<readonly [Schema.Struct<{
         readonly kind: Schema.Literal<"secret">;
         readonly secretId: Schema.brand<Schema.String, "SecretId">;
+        readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
     }>, Schema.Struct<{
         readonly kind: Schema.Literal<"connection">;
         readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
@@ -146,25 +284,8 @@ export declare const OpenApiSourceBindingInputSchema: Schema.Struct<{
         readonly text: Schema.String;
     }>]>;
 }>;
-declare const OpenApiSourceBindingInput_base: Schema.Class<OpenApiSourceBindingInput, Schema.Struct<{
-    readonly sourceId: Schema.String;
-    readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
-    readonly scope: Schema.brand<Schema.String, "ScopeId">;
-    readonly slot: Schema.String;
-    readonly value: Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"secret">;
-        readonly secretId: Schema.brand<Schema.String, "SecretId">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"connection">;
-        readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"text">;
-        readonly text: Schema.String;
-    }>]>;
-}>, {}>;
-export declare class OpenApiSourceBindingInput extends OpenApiSourceBindingInput_base {
-}
-declare const OpenApiSourceBindingRef_base: Schema.Class<OpenApiSourceBindingRef, Schema.Struct<{
+export type OpenApiSourceBindingInput = typeof OpenApiSourceBindingInput.Type;
+export declare const OpenApiSourceBindingRef: Schema.Struct<{
     readonly sourceId: Schema.String;
     readonly sourceScopeId: Schema.brand<Schema.String, "ScopeId">;
     readonly scopeId: Schema.brand<Schema.String, "ScopeId">;
@@ -172,6 +293,7 @@ declare const OpenApiSourceBindingRef_base: Schema.Class<OpenApiSourceBindingRef
     readonly value: Schema.Union<readonly [Schema.Struct<{
         readonly kind: Schema.Literal<"secret">;
         readonly secretId: Schema.brand<Schema.String, "SecretId">;
+        readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
     }>, Schema.Struct<{
         readonly kind: Schema.Literal<"connection">;
         readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
@@ -181,47 +303,11 @@ declare const OpenApiSourceBindingRef_base: Schema.Class<OpenApiSourceBindingRef
     }>]>;
     readonly createdAt: Schema.Date;
     readonly updatedAt: Schema.Date;
-}>, {}>;
-export declare class OpenApiSourceBindingRef extends OpenApiSourceBindingRef_base {
-}
+}>;
+export type OpenApiSourceBindingRef = typeof OpenApiSourceBindingRef.Type;
 export declare const OAuth2Flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
 export type OAuth2Flow = typeof OAuth2Flow.Type;
-declare const OAuth2Auth_base: Schema.Class<OAuth2Auth, Schema.Struct<{
-    readonly kind: Schema.Literal<"oauth2">;
-    /** Id of the Connection that owns this sign-in. Points at the core
-     *  `connection` table; resolve via `ctx.connections.get(id)` or
-     *  `ctx.connections.accessToken(id)`. Updated when the user signs in
-     *  again from the source detail UI (a fresh connection is minted and
-     *  this pointer is rewritten). */
-    readonly connectionId: Schema.String;
-    /** Key into `components.securitySchemes` this auth came from. Kept here
-     *  so a spec with multiple OAuth2 schemes can wire each one to its own
-     *  connection. */
-    readonly securitySchemeName: Schema.String;
-    /** OAuth2 grant type used for this source. Determines which flow the
-     *  sign-in button runs (authorizationCode opens a browser popup;
-     *  clientCredentials is server-to-server). */
-    readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
-    /** Absolute token endpoint URL. */
-    readonly tokenUrl: Schema.String;
-    /** Absolute authorization endpoint URL. Only used for authorizationCode
-     *  flows; clientCredentials has no user consent step. */
-    readonly authorizationUrl: Schema.NullOr<Schema.String>;
-    /** Expected issuer for ID token validation. Defaults to authorization origin. */
-    readonly issuerUrl: Schema.optional<Schema.NullOr<Schema.String>>;
-    /** Secret id holding the OAuth client_id. */
-    readonly clientIdSecretId: Schema.String;
-    /** Secret id holding the OAuth client_secret. Optional for public
-     *  clients (PKCE-only authorizationCode). */
-    readonly clientSecretSecretId: Schema.NullOr<Schema.String>;
-    /** OAuth scopes requested on sign-in. Stored as a static list so the
-     *  sign-in button can re-request the same capabilities without having
-     *  to re-derive them from the OpenAPI spec. */
-    readonly scopes: Schema.$Array<Schema.String>;
-}>, {}>;
-export declare class OAuth2Auth extends OAuth2Auth_base {
-}
-declare const OAuth2SourceConfig_base: Schema.Class<OAuth2SourceConfig, Schema.Struct<{
+export declare const OAuth2SourceConfig: Schema.Struct<{
     readonly kind: Schema.Literal<"oauth2">;
     readonly securitySchemeName: Schema.String;
     readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
@@ -232,31 +318,12 @@ declare const OAuth2SourceConfig_base: Schema.Class<OAuth2SourceConfig, Schema.S
     readonly clientSecretSlot: Schema.NullOr<Schema.String>;
     readonly connectionSlot: Schema.String;
     readonly scopes: Schema.$Array<Schema.String>;
-}>, {}>;
-export declare class OAuth2SourceConfig extends OAuth2SourceConfig_base {
-}
-declare const InvocationConfig_base: Schema.Class<InvocationConfig, Schema.Struct<{
-    readonly baseUrl: Schema.String;
-    /** Headers applied to every request. Values can reference secrets. */
-    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly secretId: Schema.String;
-        readonly prefix: Schema.optional<Schema.String>;
-    }>]>>>;
-    /**
-     * Optional OAuth2 auth — if set, the invoker resolves/refreshes the
-     * access token and injects `Authorization: Bearer <token>` on every
-     * request. Coexists with `headers` but wins for the Authorization header.
-     */
-    readonly oauth2: Schema.OptionFromOptional<typeof OAuth2Auth>;
-}>, {}>;
-export declare class InvocationConfig extends InvocationConfig_base {
-}
-declare const InvocationResult_base: Schema.Class<InvocationResult, Schema.Struct<{
+}>;
+export type OAuth2SourceConfig = typeof OAuth2SourceConfig.Type;
+export declare const InvocationResult: Schema.Struct<{
     readonly status: Schema.Number;
     readonly headers: Schema.$Record<Schema.String, Schema.String>;
     readonly data: Schema.NullOr<Schema.Unknown>;
     readonly error: Schema.NullOr<Schema.Unknown>;
-}>, {}>;
-export declare class InvocationResult extends InvocationResult_base {
-}
-export {};
+}>;
+export type InvocationResult = typeof InvocationResult.Type;

package/dist/sdk/usage-scope-isolation.test.d.ts

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

package/dist/testing/index.d.ts

@@ -0,0 +1,34 @@
+import { Context, Effect, Layer } from "effect";
+import { HttpClient, HttpServer } from "effect/unstable/http";
+declare const OpenApiTestServerAddressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OpenApiTestServerAddressError";
+} & Readonly<A>;
+export declare class OpenApiTestServerAddressError extends OpenApiTestServerAddressError_base<{
+    readonly address: unknown;
+}> {
+}
+declare const OpenApiTestServerSpecError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OpenApiTestServerSpecError";
+} & Readonly<A>;
+export declare class OpenApiTestServerSpecError extends OpenApiTestServerSpecError_base<{
+    readonly cause: unknown;
+}> {
+}
+export interface OpenApiTestServerOptions {
+    readonly spec: unknown;
+}
+export interface OpenApiTestServerShape {
+    readonly baseUrl: string;
+    readonly specJson: string;
+    readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>;
+}
+export declare const openApiSpecJsonWithServer: (spec: unknown, baseUrl: string) => Effect.Effect<string, OpenApiTestServerSpecError>;
+export declare const makeOpenApiTestServer: (options: OpenApiTestServerOptions) => Effect.Effect<OpenApiTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, HttpClient.HttpClient | HttpServer.HttpServer>;
+declare const OpenApiTestServer_base: Context.ServiceClass<OpenApiTestServer, "@executor-js/plugin-openapi/testing/OpenApiTestServer", OpenApiTestServerShape>;
+export declare class OpenApiTestServer extends OpenApiTestServer_base {
+    static readonly layer: (options: OpenApiTestServerOptions) => Layer.Layer<OpenApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, HttpClient.HttpClient | HttpServer.HttpServer>;
+}
+export declare const TestLayers: {
+    server: (options: OpenApiTestServerOptions) => Layer.Layer<OpenApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, HttpClient.HttpClient | HttpServer.HttpServer>;
+};
+export {};

package/dist/testing.js

@@ -0,0 +1,56 @@
+// src/testing/index.ts
+import { Context, Data, Effect, Layer, Predicate, Schema } from "effect";
+import { HttpClient, HttpServer } from "effect/unstable/http";
+var OpenApiTestServerAddressError = class extends Data.TaggedError(
+  "OpenApiTestServerAddressError"
+) {
+};
+var OpenApiTestServerSpecError = class extends Data.TaggedError("OpenApiTestServerSpecError") {
+};
+var decodeJsonSpec = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var openApiSpecJsonWithServer = (spec, baseUrl) => Effect.gen(function* () {
+  const parsed = typeof spec === "string" ? yield* decodeJsonSpec(spec).pipe(
+    Effect.mapError((cause) => new OpenApiTestServerSpecError({ cause }))
+  ) : spec;
+  const withServer = isJsonObject(parsed) ? {
+    ...parsed,
+    servers: [{ url: baseUrl }]
+  } : parsed;
+  return yield* Effect.try({
+    try: () => JSON.stringify(withServer),
+    catch: (cause) => new OpenApiTestServerSpecError({ cause })
+  });
+});
+var makeOpenApiTestServer = (options) => Effect.gen(function* () {
+  const server = yield* HttpServer.HttpServer;
+  const address = server.address;
+  if (!Predicate.isTagged(address, "TcpAddress")) {
+    return yield* new OpenApiTestServerAddressError({ address });
+  }
+  const client = yield* HttpClient.HttpClient;
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+  const specJson = yield* openApiSpecJsonWithServer(options.spec, baseUrl);
+  return {
+    baseUrl,
+    specJson,
+    httpClientLayer: Layer.succeed(HttpClient.HttpClient, client)
+  };
+});
+var OpenApiTestServer = class _OpenApiTestServer extends Context.Service()(
+  "@executor-js/plugin-openapi/testing/OpenApiTestServer"
+) {
+  static layer = (options) => Layer.effect(_OpenApiTestServer, makeOpenApiTestServer(options));
+};
+var TestLayers = {
+  server: OpenApiTestServer.layer
+};
+export {
+  OpenApiTestServer,
+  OpenApiTestServerAddressError,
+  OpenApiTestServerSpecError,
+  TestLayers,
+  makeOpenApiTestServer,
+  openApiSpecJsonWithServer
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing/index.ts"],"sourcesContent":["import { Context, Data, Effect, Layer, Predicate, Schema } from \"effect\";\nimport { HttpClient, HttpServer } from \"effect/unstable/http\";\n\nexport class OpenApiTestServerAddressError extends Data.TaggedError(\n  \"OpenApiTestServerAddressError\",\n)<{\n  readonly address: unknown;\n}> {}\n\nexport class OpenApiTestServerSpecError extends Data.TaggedError(\"OpenApiTestServerSpecError\")<{\n  readonly cause: unknown;\n}> {}\n\nexport interface OpenApiTestServerOptions {\n  readonly spec: unknown;\n}\n\nexport interface OpenApiTestServerShape {\n  readonly baseUrl: string;\n  readonly specJson: string;\n  readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>;\n}\n\nconst decodeJsonSpec = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));\n\nconst isJsonObject = (value: unknown): value is Readonly<Record<string, unknown>> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nexport const openApiSpecJsonWithServer = (\n  spec: unknown,\n  baseUrl: string,\n): Effect.Effect<string, OpenApiTestServerSpecError> =>\n  Effect.gen(function* () {\n    const parsed =\n      typeof spec === \"string\"\n        ? yield* decodeJsonSpec(spec).pipe(\n            Effect.mapError((cause) => new OpenApiTestServerSpecError({ cause })),\n          )\n        : spec;\n    const withServer = isJsonObject(parsed)\n      ? {\n          ...parsed,\n          servers: [{ url: baseUrl }],\n        }\n      : parsed;\n    return yield* Effect.try({\n      try: () => JSON.stringify(withServer),\n      catch: (cause) => new OpenApiTestServerSpecError({ cause }),\n    });\n  });\n\nexport const makeOpenApiTestServer = (\n  options: OpenApiTestServerOptions,\n): Effect.Effect<\n  OpenApiTestServerShape,\n  OpenApiTestServerAddressError | OpenApiTestServerSpecError,\n  HttpClient.HttpClient | HttpServer.HttpServer\n> =>\n  Effect.gen(function* () {\n    const server = yield* HttpServer.HttpServer;\n    const address = server.address;\n    if (!Predicate.isTagged(address, \"TcpAddress\")) {\n      return yield* new OpenApiTestServerAddressError({ address });\n    }\n\n    const client = yield* HttpClient.HttpClient;\n    const baseUrl = `http://127.0.0.1:${address.port}`;\n    const specJson = yield* openApiSpecJsonWithServer(options.spec, baseUrl);\n\n    return {\n      baseUrl,\n      specJson,\n      httpClientLayer: Layer.succeed(HttpClient.HttpClient, client),\n    };\n  });\n\nexport class OpenApiTestServer extends Context.Service<OpenApiTestServer, OpenApiTestServerShape>()(\n  \"@executor-js/plugin-openapi/testing/OpenApiTestServer\",\n) {\n  static readonly layer = (options: OpenApiTestServerOptions) =>\n    Layer.effect(OpenApiTestServer, makeOpenApiTestServer(options));\n}\n\nexport const TestLayers = {\n  server: OpenApiTestServer.layer,\n};\n"],"mappings":";AAAA,SAAS,SAAS,MAAM,QAAQ,OAAO,WAAW,cAAc;AAChE,SAAS,YAAY,kBAAkB;AAEhC,IAAM,gCAAN,cAA4C,KAAK;AAAA,EACtD;AACF,EAEG;AAAC;AAEG,IAAM,6BAAN,cAAyC,KAAK,YAAY,4BAA4B,EAE1F;AAAC;AAYJ,IAAM,iBAAiB,OAAO,oBAAoB,OAAO,eAAe,OAAO,OAAO,CAAC;AAEvF,IAAM,eAAe,CAAC,UACpB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAE9D,IAAM,4BAA4B,CACvC,MACA,YAEA,OAAO,IAAI,aAAa;AACtB,QAAM,SACJ,OAAO,SAAS,WACZ,OAAO,eAAe,IAAI,EAAE;AAAA,IAC1B,OAAO,SAAS,CAAC,UAAU,IAAI,2BAA2B,EAAE,MAAM,CAAC,CAAC;AAAA,EACtE,IACA;AACN,QAAM,aAAa,aAAa,MAAM,IAClC;AAAA,IACE,GAAG;AAAA,IACH,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC;AAAA,EAC5B,IACA;AACJ,SAAO,OAAO,OAAO,IAAI;AAAA,IACvB,KAAK,MAAM,KAAK,UAAU,UAAU;AAAA,IACpC,OAAO,CAAC,UAAU,IAAI,2BAA2B,EAAE,MAAM,CAAC;AAAA,EAC5D,CAAC;AACH,CAAC;AAEI,IAAM,wBAAwB,CACnC,YAMA,OAAO,IAAI,aAAa;AACtB,QAAM,SAAS,OAAO,WAAW;AACjC,QAAM,UAAU,OAAO;AACvB,MAAI,CAAC,UAAU,SAAS,SAAS,YAAY,GAAG;AAC9C,WAAO,OAAO,IAAI,8BAA8B,EAAE,QAAQ,CAAC;AAAA,EAC7D;AAEA,QAAM,SAAS,OAAO,WAAW;AACjC,QAAM,UAAU,oBAAoB,QAAQ,IAAI;AAChD,QAAM,WAAW,OAAO,0BAA0B,QAAQ,MAAM,OAAO;AAEvE,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,iBAAiB,MAAM,QAAQ,WAAW,YAAY,MAAM;AAAA,EAC9D;AACF,CAAC;AAEI,IAAM,oBAAN,MAAM,2BAA0B,QAAQ,QAAmD;AAAA,EAChG;AACF,EAAE;AAAA,EACA,OAAgB,QAAQ,CAAC,YACvB,MAAM,OAAO,oBAAmB,sBAAsB,OAAO,CAAC;AAClE;AAEO,IAAM,aAAa;AAAA,EACxB,QAAQ,kBAAkB;AAC5B;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executor-js/plugin-openapi",
-  "version": "0.1.0",
+  "version": "1.4.20",
   "homepage": "https://github.com/RhysSullivan/executor/tree/main/packages/plugins/openapi",
   "bugs": {
     "url": "https://github.com/RhysSullivan/executor/issues"
@@ -27,6 +27,18 @@
         "types": "./dist/sdk/index.d.ts",
         "default": "./dist/core.js"
       }
+    },
+    "./client": {
+      "import": {
+        "types": "./dist/react/plugin-client.d.ts",
+        "default": "./dist/client.js"
+      }
+    },
+    "./testing": {
+      "import": {
+        "types": "./dist/testing/index.d.ts",
+        "default": "./dist/testing.js"
+      }
     }
   },
   "publishConfig": {
@@ -41,8 +53,8 @@
   },
   "dependencies": {
     "@effect/platform-node": "4.0.0-beta.59",
-    "@executor-js/config": "0.1.0",
-    "@executor-js/sdk": "0.1.0",
+    "@executor-js/config": "1.4.20",
+    "@executor-js/sdk": "1.4.20",
     "effect": "4.0.0-beta.59",
     "openapi-types": "^12.1.3",
     "yaml": "^2.7.1"
@@ -50,7 +62,7 @@
   "devDependencies": {
     "@effect/atom-react": "4.0.0-beta.59",
     "@effect/vitest": "4.0.0-beta.59",
-    "@executor-js/storage-core": "0.1.0",
+    "@executor-js/storage-core": "1.4.20",
     "@types/node": "^24.3.1",
     "@types/react": "^19.1.0",
     "bun-types": "^1.2.22",