@executor-js/sdk 0.0.1-beta.6 → 0.0.2

package/dist/chunk-6LMMN2GP.js

@@ -0,0 +1,4396 @@
+// src/blob.ts
+import { Effect } from "effect";
+import { StorageError } from "@executor-js/storage-core";
+var assertScope = (scope, scopes) => scopes.includes(scope) ? Effect.void : Effect.fail(
+  new StorageError({
+    message: `Blob write targets scope "${scope}" which is not in the executor's scope stack [${scopes.join(", ")}].`,
+    cause: void 0
+  })
+);
+var nsFor = (scope, pluginId) => `${scope}/${pluginId}`;
+var pluginBlobStore = (store, scopes, pluginId) => ({
+  get: (key) => Effect.gen(function* () {
+    const namespaces = scopes.map((s) => nsFor(s, pluginId));
+    const hits = yield* store.getMany(namespaces, key);
+    if (hits.size === 0) return null;
+    for (const ns of namespaces) {
+      const v = hits.get(ns);
+      if (v !== void 0) return v;
+    }
+    return null;
+  }),
+  put: (key, value, options) => Effect.flatMap(
+    assertScope(options.scope, scopes),
+    () => store.put(nsFor(options.scope, pluginId), key, value)
+  ),
+  delete: (key, options) => Effect.flatMap(
+    assertScope(options.scope, scopes),
+    () => store.delete(nsFor(options.scope, pluginId), key)
+  ),
+  has: (key) => store.getMany(
+    scopes.map((s) => nsFor(s, pluginId)),
+    key
+  ).pipe(Effect.map((hits) => hits.size > 0))
+});
+var makeInMemoryBlobStore = () => {
+  const store = /* @__PURE__ */ new Map();
+  const k = (ns, key) => `${ns}::${key}`;
+  return {
+    get: (ns, key) => Effect.sync(() => store.get(k(ns, key)) ?? null),
+    getMany: (namespaces, key) => Effect.sync(() => {
+      const hits = /* @__PURE__ */ new Map();
+      for (const ns of namespaces) {
+        const v = store.get(k(ns, key));
+        if (v !== void 0) hits.set(ns, v);
+      }
+      return hits;
+    }),
+    put: (ns, key, value) => Effect.sync(() => {
+      store.set(k(ns, key), value);
+    }),
+    delete: (ns, key) => Effect.sync(() => {
+      store.delete(k(ns, key));
+    }),
+    has: (ns, key) => Effect.sync(() => store.has(k(ns, key)))
+  };
+};
+
+// src/ids.ts
+import { Schema } from "effect";
+var ScopeId = Schema.String.pipe(Schema.brand("ScopeId"));
+var ToolId = Schema.String.pipe(Schema.brand("ToolId"));
+var SecretId = Schema.String.pipe(Schema.brand("SecretId"));
+var PolicyId = Schema.String.pipe(Schema.brand("PolicyId"));
+var ConnectionId = Schema.String.pipe(Schema.brand("ConnectionId"));
+
+// src/connections.ts
+import { Data, Schema as Schema2 } from "effect";
+var ConnectionProviderState = Schema2.Record(Schema2.String, Schema2.Unknown);
+var ConnectionRef = class extends Schema2.Class("ConnectionRef")({
+  id: ConnectionId,
+  scopeId: ScopeId,
+  provider: Schema2.String,
+  identityLabel: Schema2.NullOr(Schema2.String),
+  accessTokenSecretId: SecretId,
+  refreshTokenSecretId: Schema2.NullOr(SecretId),
+  /** Epoch ms when the access token expires; null if not declared. */
+  expiresAt: Schema2.NullOr(Schema2.Number),
+  /** OAuth-style scope string as returned by the token endpoint. Named
+   *  `oauthScope` to avoid collision with the executor scope id. */
+  oauthScope: Schema2.NullOr(Schema2.String),
+  providerState: Schema2.NullOr(ConnectionProviderState),
+  createdAt: Schema2.Date,
+  updatedAt: Schema2.Date
+}) {
+};
+var TokenMaterial = class extends Schema2.Class("TokenMaterial")({
+  /** Target secret id. Plugins typically derive this from the source id
+   *  + a stable suffix (e.g. `${sourceId}.access_token`). */
+  secretId: SecretId,
+  /** Display name stamped on the secret row. Only visible to code — the
+   *  Connections UI hides connection-owned secrets. */
+  name: Schema2.String,
+  value: Schema2.String
+}) {
+};
+var CreateConnectionInput = class extends Schema2.Class(
+  "CreateConnectionInput"
+)({
+  id: ConnectionId,
+  /** Executor scope id that will own this connection + its backing
+   *  secrets. This is the sharing boundary: a user scope is personal,
+   *  an org/workspace scope is shared with descendants. */
+  scope: ScopeId,
+  provider: Schema2.String,
+  identityLabel: Schema2.NullOr(Schema2.String),
+  accessToken: TokenMaterial,
+  refreshToken: Schema2.NullOr(TokenMaterial),
+  expiresAt: Schema2.NullOr(Schema2.Number),
+  /** OAuth-style scope string. Distinct from the executor scope above. */
+  oauthScope: Schema2.NullOr(Schema2.String),
+  providerState: Schema2.NullOr(ConnectionProviderState)
+}) {
+};
+var ConnectionRefreshError = class extends Data.TaggedError(
+  "ConnectionRefreshError"
+) {
+};
+var UpdateConnectionTokensInput = class extends Schema2.Class(
+  "UpdateConnectionTokensInput"
+)({
+  id: ConnectionId,
+  accessToken: Schema2.String,
+  refreshToken: Schema2.optional(Schema2.NullOr(Schema2.String)),
+  expiresAt: Schema2.optional(Schema2.NullOr(Schema2.Number)),
+  oauthScope: Schema2.optional(Schema2.NullOr(Schema2.String)),
+  providerState: Schema2.optional(Schema2.NullOr(ConnectionProviderState)),
+  identityLabel: Schema2.optional(Schema2.NullOr(Schema2.String))
+}) {
+};
+
+// src/core-schema.ts
+var coreSchema = {
+  source: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      plugin_id: { type: "string", required: true, index: true },
+      kind: { type: "string", required: true },
+      name: { type: "string", required: true },
+      url: { type: "string", required: false },
+      can_remove: {
+        type: "boolean",
+        required: true,
+        defaultValue: true
+      },
+      can_refresh: {
+        type: "boolean",
+        required: true,
+        defaultValue: false
+      },
+      can_edit: {
+        type: "boolean",
+        required: true,
+        defaultValue: false
+      },
+      created_at: { type: "date", required: true },
+      updated_at: { type: "date", required: true }
+    }
+  },
+  tool: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      source_id: { type: "string", required: true, index: true },
+      plugin_id: { type: "string", required: true, index: true },
+      name: { type: "string", required: true },
+      description: { type: "string", required: true },
+      input_schema: { type: "json", required: false },
+      output_schema: { type: "json", required: false },
+      // NOTE: tool annotations (requiresApproval, approvalDescription,
+      // mayElicit) are NOT stored on this row. They're derived at read
+      // time from plugin-owned data via `plugin.resolveAnnotations`,
+      // because the source of truth already lives in each plugin's own
+      // storage (openapi's OperationBinding, etc.) and duplicating it
+      // here would just mean bulk-rewriting rows every time the
+      // derivation logic changes.
+      created_at: { type: "date", required: true },
+      updated_at: { type: "date", required: true }
+    }
+  },
+  // Shared JSON-schema `$defs` stored once per source. Tool input/output
+  // schemas carry `$ref: "#/$defs/X"` pointers; the read path attaches
+  // matching defs under `$defs` before returning. Keyed by synthetic id
+  // `${source_id}.${name}` so cleanup on source removal is a single
+  // deleteMany by source_id.
+  definition: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      source_id: { type: "string", required: true, index: true },
+      plugin_id: { type: "string", required: true, index: true },
+      name: { type: "string", required: true },
+      schema: { type: "json", required: true },
+      created_at: { type: "date", required: true }
+    }
+  },
+  // Secrets live in the core surface as metadata (id, display name,
+  // provider key). Actual values never touch this table — they live in
+  // the secret provider (keychain, 1password, file, etc.) and are
+  // resolved on demand via `ctx.secrets.get(id)`.
+  //
+  // `owned_by_connection_id` ties the row to a connection. Connection-
+  // owned secrets are plumbing, not user-facing values: `ctx.secrets.list`
+  // filters them out (the user sees the Connection instead), and
+  // `ctx.secrets.remove` refuses to delete them (Connection.remove is
+  // the single owner of the lifecycle). The FK is nullable so existing
+  // "bare" secrets (API keys entered by the user, pre-connection OAuth
+  // rows during migration) remain visible and removable unchanged.
+  secret: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      name: { type: "string", required: true },
+      provider: { type: "string", required: true, index: true },
+      owned_by_connection_id: {
+        type: "string",
+        required: false,
+        index: true
+      },
+      created_at: { type: "date", required: true }
+    }
+  },
+  // Connections — sign-in state for one identity against one remote
+  // provider. A Connection owns one or more `secret` rows (access +
+  // refresh tokens, etc.) via `secret.owned_by_connection_id`, and the
+  // SDK exposes `ctx.connections.accessToken(id)` which transparently
+  // refreshes the backing secrets when they're near expiry. Plugins
+  // contribute refresh behavior via `plugin.connectionProviders[].refresh`
+  // keyed by `provider`, same pattern as `secretProviders`.
+  //
+  // `provider_state` is plugin-owned opaque JSON — token endpoint URL,
+  // scopes, issuer, auth-server metadata — whatever the provider's
+  // refresh handler needs to re-hit the token endpoint. It's NOT
+  // sensitive (all secrets go through the provider-backed secret rows);
+  // it's just enough metadata to drive a refresh without re-running
+  // discovery.
+  connection: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      /** Routing key into `plugin.connectionProviders`. Typical shape
+       *  is `${pluginId}:${kind}` (e.g. `openapi:oauth2`, `mcp:oauth2`,
+       *  `google-discovery:google`). Mirrors `secret.provider`. */
+      provider: { type: "string", required: true, index: true },
+      /** Display label shown in the Connections UI. Usually the account
+       *  email / handle / org name the user signed in as. */
+      identity_label: { type: "string", required: false },
+      /** Stable id of the access-token secret. Always present. */
+      access_token_secret_id: { type: "string", required: true },
+      /** Stable id of the refresh-token secret. Null for flows that
+       *  don't mint a refresh token (client_credentials, etc.). */
+      refresh_token_secret_id: { type: "string", required: false },
+      /** Epoch ms when the access token expires. Null if the provider
+       *  didn't declare an expiry. Used as the refresh trigger. Stored as
+       *  `bigint` because `Date.now()` overflows int32. */
+      expires_at: { type: "number", required: false, bigint: true },
+      /** Scope string as returned by the token endpoint. */
+      scope: { type: "string", required: false },
+      /** Opaque plugin-owned JSON — token endpoint URL, scopes list,
+       *  discovery hints, etc. Never sensitive. */
+      provider_state: { type: "json", required: false },
+      created_at: { type: "date", required: true },
+      updated_at: { type: "date", required: true }
+    }
+  },
+  // Pending OAuth authorization rows shared by every OAuth-capable plugin.
+  // Rows are short-lived and deleted after completion/cancel; the resulting
+  // `connection` row is the durable sign-in state.
+  oauth2_session: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      plugin_id: { type: "string", required: true, index: true },
+      strategy: { type: "string", required: true },
+      connection_id: { type: "string", required: true, index: true },
+      token_scope: { type: "string", required: true },
+      redirect_url: { type: "string", required: true },
+      payload: { type: "json", required: true },
+      expires_at: { type: "number", required: true, bigint: true },
+      created_at: { type: "date", required: true }
+    }
+  },
+  // User-authored overrides for tool permissions. Each row is one rule:
+  // a glob-ish pattern + an action (approve / require_approval / block).
+  // Resolution walks the scope stack innermost-first, then `position`
+  // ascending within each scope; first match wins. Plugin-derived
+  // annotations from `resolveAnnotations` apply only when no rule
+  // matches.
+  //
+  // Pattern grammar (v1):
+  //   - `*`                  every tool id (universal)
+  //   - `vercel.dns.create`  exact tool id
+  //   - `vercel.dns.*`       any tool whose id starts with `vercel.dns.`
+  //   - `vercel.*`           plugin-wide
+  // No `**`, no brace expansion, no leading-`*` prefixes (`*foo`, `*.foo`).
+  tool_policy: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      pattern: { type: "string", required: true },
+      /** "approve" | "require_approval" | "block". */
+      action: { type: "string", required: true },
+      /** Fractional-indexing key (Jira lexorank style). Lower lex order =
+       *  higher precedence. New rules default to a key generated above
+       *  the current minimum. Strings instead of numbers so we can
+       *  always lengthen the key to insert between two adjacent rows
+       *  without precision loss; see `fractional-indexing` in
+       *  `policies.ts`. */
+      position: { type: "string", required: true, index: true },
+      created_at: { type: "date", required: true },
+      updated_at: { type: "date", required: true }
+    }
+  }
+};
+var TOOL_POLICY_ACTIONS = [
+  "approve",
+  "require_approval",
+  "block"
+];
+var isToolPolicyAction = (value) => typeof value === "string" && TOOL_POLICY_ACTIONS.includes(value);
+
+// src/elicitation.ts
+import { Schema as Schema3 } from "effect";
+var FormElicitation = class extends Schema3.TaggedClass()("FormElicitation", {
+  message: Schema3.String,
+  /** JSON Schema describing the fields to collect */
+  requestedSchema: Schema3.Record(Schema3.String, Schema3.Unknown)
+}) {
+};
+var UrlElicitation = class extends Schema3.TaggedClass()("UrlElicitation", {
+  message: Schema3.String,
+  url: Schema3.String,
+  /** Unique ID so the host can correlate the callback */
+  elicitationId: Schema3.String
+}) {
+};
+var ElicitationAction = Schema3.Literals(["accept", "decline", "cancel"]);
+var ElicitationResponse = class extends Schema3.Class("ElicitationResponse")({
+  action: ElicitationAction,
+  /** Present when action is "accept" — the data the user provided */
+  content: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown))
+}) {
+};
+var ElicitationDeclinedError = class extends Schema3.TaggedErrorClass()(
+  "ElicitationDeclinedError",
+  {
+    toolId: ToolId,
+    action: Schema3.Literals(["decline", "cancel"])
+  }
+) {
+};
+
+// src/errors.ts
+import { Data as Data2, Schema as Schema4 } from "effect";
+var ToolNotFoundError = class extends Schema4.TaggedErrorClass()(
+  "ToolNotFoundError",
+  { toolId: ToolId }
+) {
+};
+var ToolInvocationError = class extends Data2.TaggedError("ToolInvocationError") {
+};
+var PluginNotLoadedError = class extends Schema4.TaggedErrorClass()(
+  "PluginNotLoadedError",
+  {
+    pluginId: Schema4.String,
+    toolId: ToolId
+  }
+) {
+};
+var NoHandlerError = class extends Schema4.TaggedErrorClass()(
+  "NoHandlerError",
+  {
+    toolId: ToolId,
+    pluginId: Schema4.String
+  }
+) {
+};
+var ToolBlockedError = class extends Schema4.TaggedErrorClass()(
+  "ToolBlockedError",
+  {
+    toolId: ToolId,
+    pattern: Schema4.String
+  }
+) {
+};
+var SourceNotFoundError = class extends Schema4.TaggedErrorClass()(
+  "SourceNotFoundError",
+  { sourceId: Schema4.String }
+) {
+};
+var SourceRemovalNotAllowedError = class extends Schema4.TaggedErrorClass()(
+  "SourceRemovalNotAllowedError",
+  { sourceId: Schema4.String }
+) {
+};
+var SecretNotFoundError = class extends Schema4.TaggedErrorClass()(
+  "SecretNotFoundError",
+  { secretId: SecretId }
+) {
+};
+var SecretResolutionError = class extends Schema4.TaggedErrorClass()(
+  "SecretResolutionError",
+  {
+    secretId: SecretId,
+    message: Schema4.String
+  }
+) {
+};
+var SecretOwnedByConnectionError = class extends Schema4.TaggedErrorClass()(
+  "SecretOwnedByConnectionError",
+  {
+    secretId: SecretId,
+    connectionId: ConnectionId
+  }
+) {
+};
+var ConnectionNotFoundError = class extends Schema4.TaggedErrorClass()(
+  "ConnectionNotFoundError",
+  { connectionId: ConnectionId }
+) {
+};
+var ConnectionProviderNotRegisteredError = class extends Schema4.TaggedErrorClass()(
+  "ConnectionProviderNotRegisteredError",
+  {
+    provider: Schema4.String,
+    connectionId: Schema4.optional(ConnectionId)
+  }
+) {
+};
+var ConnectionRefreshNotSupportedError = class extends Schema4.TaggedErrorClass()(
+  "ConnectionRefreshNotSupportedError",
+  {
+    connectionId: ConnectionId,
+    provider: Schema4.String
+  }
+) {
+};
+var ConnectionReauthRequiredError = class extends Schema4.TaggedErrorClass()(
+  "ConnectionReauthRequiredError",
+  {
+    connectionId: ConnectionId,
+    provider: Schema4.String,
+    message: Schema4.String
+  }
+) {
+};
+
+// src/secrets.ts
+import { Schema as Schema5 } from "effect";
+var SecretRef = class extends Schema5.Class("SecretRef")({
+  id: SecretId,
+  scopeId: ScopeId,
+  /** Human-readable label (e.g. "Cloudflare API Token") */
+  name: Schema5.String,
+  /** Which provider holds the value */
+  provider: Schema5.String,
+  createdAt: Schema5.Date
+}) {
+};
+var SetSecretInput = class extends Schema5.Class(
+  "SetSecretInput"
+)({
+  id: SecretId,
+  /** Scope id to own this secret. Must be one of the executor's
+   *  configured scopes. */
+  scope: ScopeId,
+  /** Display name shown in secret-list UI. */
+  name: Schema5.String,
+  /** The secret value itself — never persisted outside the provider. */
+  value: Schema5.String,
+  /** Optional provider routing. If unset the executor picks the first
+   *  writable provider in registration order. */
+  provider: Schema5.optional(Schema5.String)
+}) {
+};
+
+// src/oauth.ts
+import { Effect as Effect5, Schema as Schema6 } from "effect";
+var OAuthDynamicDcrStrategy = Schema6.Struct({
+  kind: Schema6.Literal("dynamic-dcr"),
+  /** Scopes to request. Defaults to whatever `scopes_supported`
+   *  advertises; caller can narrow or extend. */
+  scopes: Schema6.optional(Schema6.Array(Schema6.String))
+});
+var OAuthAuthorizationCodeStrategy = Schema6.Struct({
+  kind: Schema6.Literal("authorization-code"),
+  authorizationEndpoint: Schema6.String,
+  tokenEndpoint: Schema6.String,
+  /** Expected authorization-server issuer for ID token validation. Some
+   *  providers use a token endpoint host that differs from issuer, or a
+   *  path-scoped issuer such as Okta custom authorization servers. */
+  issuerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
+  /** Secret id holding the `client_id`. Using a secret row rather than
+   *  an inline string so the value lives at the scope where the caller
+   *  configured it and shadowing behaves consistently. */
+  clientIdSecretId: Schema6.String,
+  /** Secret id for `client_secret`. Null for public clients using
+   *  PKCE without a confidential secret. */
+  clientSecretSecretId: Schema6.NullOr(Schema6.String),
+  scopes: Schema6.Array(Schema6.String),
+  /** Separator between scopes. RFC 6749 says space; some providers
+   *  (GitHub classic) use comma. */
+  scopeSeparator: Schema6.optional(Schema6.String),
+  /** Provider-specific params injected at authorization URL build time
+   *  (Google's `access_type=offline`, `prompt=consent`, ...). */
+  extraAuthorizationParams: Schema6.optional(
+    Schema6.Record(Schema6.String, Schema6.String)
+  ),
+  /** `"body"` (default) sends client creds in the form body; `"basic"`
+   *  uses HTTP Basic auth. Stripe-style servers require basic. */
+  clientAuth: Schema6.optional(Schema6.Literals(["body", "basic"]))
+});
+var OAuthClientCredentialsStrategy = Schema6.Struct({
+  kind: Schema6.Literal("client-credentials"),
+  tokenEndpoint: Schema6.String,
+  clientIdSecretId: Schema6.String,
+  clientSecretSecretId: Schema6.String,
+  scopes: Schema6.optional(Schema6.Array(Schema6.String)),
+  scopeSeparator: Schema6.optional(Schema6.String),
+  clientAuth: Schema6.optional(Schema6.Literals(["body", "basic"]))
+});
+var OAuthStrategy = Schema6.Union([
+  OAuthDynamicDcrStrategy,
+  OAuthAuthorizationCodeStrategy,
+  OAuthClientCredentialsStrategy
+]);
+var OAuthProviderState = Schema6.Union([
+  Schema6.Struct({
+    kind: Schema6.Literal("dynamic-dcr"),
+    tokenEndpoint: Schema6.String,
+    issuerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
+    authorizationServerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
+    authorizationServerMetadataUrl: Schema6.NullOr(Schema6.String),
+    idTokenSigningAlgValuesSupported: Schema6.optional(
+      Schema6.Array(Schema6.String)
+    ),
+    /** DCR-minted client_id. Embedded inline (not a secret) — DCR
+     *  clients are public-ish by design; the secret part (if the AS
+     *  issued one) is a separate secret row. */
+    clientId: Schema6.String,
+    clientSecretSecretId: Schema6.NullOr(Schema6.String),
+    clientAuth: Schema6.Literals(["body", "basic"]),
+    scopes: Schema6.Array(Schema6.String).pipe(Schema6.withDecodingDefaultType(Effect5.succeed([]))),
+    scopeSeparator: Schema6.optional(Schema6.String),
+    scope: Schema6.NullOr(Schema6.String)
+  }),
+  Schema6.Struct({
+    kind: Schema6.Literal("authorization-code"),
+    tokenEndpoint: Schema6.String,
+    issuerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
+    clientIdSecretId: Schema6.String,
+    clientSecretSecretId: Schema6.NullOr(Schema6.String),
+    clientAuth: Schema6.Literals(["body", "basic"]),
+    scopes: Schema6.Array(Schema6.String).pipe(Schema6.withDecodingDefaultType(Effect5.succeed([]))),
+    scopeSeparator: Schema6.optional(Schema6.String),
+    scope: Schema6.NullOr(Schema6.String)
+  }),
+  Schema6.Struct({
+    kind: Schema6.Literal("client-credentials"),
+    tokenEndpoint: Schema6.String,
+    clientIdSecretId: Schema6.String,
+    clientSecretSecretId: Schema6.String,
+    scopes: Schema6.Array(Schema6.String),
+    scopeSeparator: Schema6.optional(Schema6.String),
+    clientAuth: Schema6.Literals(["body", "basic"]),
+    scope: Schema6.NullOr(Schema6.String)
+  })
+]);
+var OAUTH2_PROVIDER_KEY = "oauth2";
+var OAuthProbeError = class extends Schema6.TaggedErrorClass()(
+  "OAuthProbeError",
+  {
+    message: Schema6.String
+  }
+) {
+  static annotations = { httpApiStatus: 400 };
+};
+var OAuthStartError = class extends Schema6.TaggedErrorClass()(
+  "OAuthStartError",
+  {
+    message: Schema6.String
+  }
+) {
+  static annotations = { httpApiStatus: 400 };
+};
+var OAuthCompleteError = class extends Schema6.TaggedErrorClass()(
+  "OAuthCompleteError",
+  {
+    message: Schema6.String,
+    /** RFC 6749 §5.2 error code, when the token endpoint returned one.
+     *  Callers distinguish terminal failures (`invalid_grant` ⇒
+     *  re-auth required) from transient ones. */
+    code: Schema6.optional(Schema6.String)
+  }
+) {
+  static annotations = { httpApiStatus: 400 };
+};
+var OAuthSessionNotFoundError = class extends Schema6.TaggedErrorClass()(
+  "OAuthSessionNotFoundError",
+  {
+    sessionId: Schema6.String
+  }
+) {
+  static annotations = { httpApiStatus: 404 };
+};
+var OAUTH2_SESSION_TTL_MS = 15 * 60 * 1e3;
+
+// src/oauth-helpers.ts
+import { Data as Data3, Effect as Effect6 } from "effect";
+import * as oauth from "oauth4webapi";
+var OAuth2Error = class extends Data3.TaggedError("OAuth2Error") {
+};
+var OAUTH2_REFRESH_SKEW_MS = 6e4;
+var OAUTH2_DEFAULT_TIMEOUT_MS = 2e4;
+var createPkceCodeVerifier = () => oauth.generateRandomCodeVerifier();
+var createPkceCodeChallenge = (verifier) => oauth.calculatePKCECodeChallenge(verifier);
+var buildAuthorizationUrl = (input) => {
+  const url = new URL(input.authorizationUrl);
+  const separator = input.scopeSeparator ?? " ";
+  url.searchParams.set("client_id", input.clientId);
+  url.searchParams.set("redirect_uri", input.redirectUrl);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("scope", input.scopes.join(separator));
+  url.searchParams.set("state", input.state);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("code_challenge", input.codeChallenge);
+  if (input.extraParams) {
+    for (const [k, v] of Object.entries(input.extraParams)) {
+      url.searchParams.set(k, v);
+    }
+  }
+  return url.toString();
+};
+var toOAuth2Error = (cause) => {
+  if (typeof cause === "object" && cause !== null) {
+    const c = cause;
+    const code = typeof c.error === "string" ? c.error : void 0;
+    const description = typeof c.error_description === "string" ? c.error_description : typeof c.message === "string" ? c.message : void 0;
+    return new OAuth2Error({
+      message: `OAuth token exchange failed: ${description ?? code ?? "unknown error"}`,
+      error: code,
+      cause
+    });
+  }
+  return new OAuth2Error({
+    message: `OAuth token exchange failed: ${String(cause)}`,
+    cause
+  });
+};
+var asFromTokenUrl = (tokenUrl) => {
+  const url = new URL(tokenUrl);
+  return {
+    issuer: `${url.protocol}//${url.host}`,
+    token_endpoint: tokenUrl
+  };
+};
+var asFromTokenUrlAndIssuer = (tokenUrl, issuerUrl, options = {}) => {
+  const as = asFromTokenUrl(tokenUrl);
+  const withIssuer = issuerUrl ? { ...as, issuer: issuerUrl } : as;
+  return options.idTokenSigningAlgValuesSupported ? {
+    ...withIssuer,
+    id_token_signing_alg_values_supported: [
+      ...options.idTokenSigningAlgValuesSupported
+    ]
+  } : withIssuer;
+};
+var isLoopbackHttpUrl = (value) => {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:") return false;
+    const hostname = url.hostname.toLowerCase();
+    return hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1" || hostname === "[::1]" || hostname.startsWith("127.");
+  } catch {
+    return false;
+  }
+};
+var oauth4webapiRequestOptions = (targetUrl, timeoutMs) => {
+  const options = {
+    signal: AbortSignal.timeout(timeoutMs ?? OAUTH2_DEFAULT_TIMEOUT_MS)
+  };
+  if (isLoopbackHttpUrl(targetUrl)) {
+    options[oauth.allowInsecureRequests] = true;
+  }
+  return options;
+};
+var pickClientAuth = (clientSecret, method) => {
+  if (!clientSecret) return oauth.None();
+  return method === "basic" ? oauth.ClientSecretBasic(clientSecret) : oauth.ClientSecretPost(clientSecret);
+};
+var tokenResponseFrom = (r) => ({
+  access_token: r.access_token,
+  token_type: r.token_type,
+  refresh_token: r.refresh_token,
+  expires_in: typeof r.expires_in === "number" ? r.expires_in : void 0,
+  scope: r.scope
+});
+var isUnexpectedIdTokenAlg = (cause) => cause instanceof Error && cause.message.includes('unexpected JWT "alg" header parameter');
+var looseTokenResponseFrom = (body) => {
+  if (typeof body !== "object" || body === null) {
+    throw new Error("token endpoint response body is not an object");
+  }
+  const record = body;
+  if (typeof record.access_token !== "string" || !record.access_token) {
+    throw new Error('token endpoint response is missing "access_token"');
+  }
+  const expiresIn = typeof record.expires_in === "number" ? record.expires_in : typeof record.expires_in === "string" ? Number.parseFloat(record.expires_in) : void 0;
+  if (expiresIn !== void 0 && !Number.isFinite(expiresIn)) {
+    throw new Error('token endpoint response has invalid "expires_in"');
+  }
+  return {
+    access_token: record.access_token,
+    token_type: typeof record.token_type === "string" ? record.token_type : void 0,
+    refresh_token: typeof record.refresh_token === "string" ? record.refresh_token : void 0,
+    expires_in: expiresIn,
+    scope: typeof record.scope === "string" ? record.scope : void 0
+  };
+};
+var processTokenEndpointResponse = async (as, client, response) => {
+  const fallback = response.clone();
+  try {
+    return tokenResponseFrom(
+      await oauth.processGenericTokenEndpointResponse(as, client, response)
+    );
+  } catch (cause) {
+    if (!isUnexpectedIdTokenAlg(cause)) throw cause;
+    return looseTokenResponseFrom(await fallback.json());
+  }
+};
+var exchangeAuthorizationCode = (input) => Effect6.tryPromise({
+  try: async () => {
+    const as = asFromTokenUrlAndIssuer(input.tokenUrl, input.issuerUrl, {
+      idTokenSigningAlgValuesSupported: input.idTokenSigningAlgValuesSupported
+    });
+    const client = { client_id: input.clientId };
+    const clientAuth = pickClientAuth(
+      input.clientSecret,
+      input.clientAuth ?? "body"
+    );
+    const params = new URLSearchParams({
+      code: input.code,
+      redirect_uri: input.redirectUrl,
+      code_verifier: input.codeVerifier
+    });
+    const response = await oauth.genericTokenEndpointRequest(
+      as,
+      client,
+      clientAuth,
+      "authorization_code",
+      params,
+      oauth4webapiRequestOptions(input.tokenUrl, input.timeoutMs)
+    );
+    return processTokenEndpointResponse(as, client, response);
+  },
+  catch: toOAuth2Error
+});
+var exchangeClientCredentials = (input) => Effect6.tryPromise({
+  try: async () => {
+    const as = asFromTokenUrl(input.tokenUrl);
+    const client = { client_id: input.clientId };
+    const clientAuth = pickClientAuth(
+      input.clientSecret,
+      input.clientAuth ?? "body"
+    );
+    const params = new URLSearchParams();
+    if (input.scopes && input.scopes.length > 0) {
+      params.set("scope", input.scopes.join(input.scopeSeparator ?? " "));
+    }
+    const response = await oauth.clientCredentialsGrantRequest(
+      as,
+      client,
+      clientAuth,
+      params,
+      oauth4webapiRequestOptions(input.tokenUrl, input.timeoutMs)
+    );
+    const result = await oauth.processClientCredentialsResponse(
+      as,
+      client,
+      response
+    );
+    return tokenResponseFrom(result);
+  },
+  catch: toOAuth2Error
+});
+var refreshAccessToken = (input) => Effect6.tryPromise({
+  try: async () => {
+    const as = asFromTokenUrlAndIssuer(input.tokenUrl, input.issuerUrl, {
+      idTokenSigningAlgValuesSupported: input.idTokenSigningAlgValuesSupported
+    });
+    const client = { client_id: input.clientId };
+    const clientAuth = pickClientAuth(
+      input.clientSecret,
+      input.clientAuth ?? "body"
+    );
+    const additionalParameters = input.scopes && input.scopes.length > 0 ? new URLSearchParams({
+      scope: input.scopes.join(input.scopeSeparator ?? " ")
+    }) : void 0;
+    const response = await oauth.refreshTokenGrantRequest(
+      as,
+      client,
+      clientAuth,
+      input.refreshToken,
+      {
+        ...oauth4webapiRequestOptions(input.tokenUrl, input.timeoutMs),
+        additionalParameters
+      }
+    );
+    const fallback = response.clone();
+    try {
+      const result = await oauth.processRefreshTokenResponse(
+        as,
+        client,
+        response
+      );
+      return tokenResponseFrom(result);
+    } catch (cause) {
+      if (!isUnexpectedIdTokenAlg(cause)) throw cause;
+      return looseTokenResponseFrom(await fallback.json());
+    }
+  },
+  catch: toOAuth2Error
+});
+var shouldRefreshToken = (input) => {
+  if (input.expiresAt === null) return false;
+  const now = input.now ?? Date.now();
+  const skew = input.skewMs ?? OAUTH2_REFRESH_SKEW_MS;
+  return input.expiresAt <= now + skew;
+};
+
+// src/oauth-discovery.ts
+import { Data as Data4, Effect as Effect7, Result, Schema as Schema7 } from "effect";
+import * as oauth2 from "oauth4webapi";
+var OAuthDiscoveryError = class extends Data4.TaggedError(
+  "OAuthDiscoveryError"
+) {
+};
+var discoveryError = (message, options = {}) => new OAuthDiscoveryError({
+  message,
+  status: options.status,
+  cause: options.cause
+});
+var StringArray = Schema7.Array(Schema7.String);
+var OAuthProtectedResourceMetadataSchema = Schema7.Struct({
+  resource: Schema7.optional(Schema7.String),
+  authorization_servers: Schema7.optional(StringArray),
+  scopes_supported: Schema7.optional(StringArray),
+  bearer_methods_supported: Schema7.optional(StringArray),
+  resource_documentation: Schema7.optional(Schema7.String)
+}).annotate({ identifier: "OAuthProtectedResourceMetadata" });
+var OAuthAuthorizationServerMetadataSchema = Schema7.Struct({
+  issuer: Schema7.String,
+  authorization_endpoint: Schema7.String,
+  token_endpoint: Schema7.String,
+  registration_endpoint: Schema7.optional(Schema7.String),
+  scopes_supported: Schema7.optional(StringArray),
+  response_types_supported: Schema7.optional(StringArray),
+  grant_types_supported: Schema7.optional(StringArray),
+  code_challenge_methods_supported: Schema7.optional(StringArray),
+  token_endpoint_auth_methods_supported: Schema7.optional(StringArray),
+  revocation_endpoint: Schema7.optional(Schema7.String),
+  introspection_endpoint: Schema7.optional(Schema7.String),
+  userinfo_endpoint: Schema7.optional(Schema7.String),
+  id_token_signing_alg_values_supported: Schema7.optional(StringArray)
+}).annotate({ identifier: "OAuthAuthorizationServerMetadata" });
+var OAuthClientInformationSchema = Schema7.Struct({
+  client_id: Schema7.String,
+  client_secret: Schema7.optional(Schema7.String),
+  client_id_issued_at: Schema7.optional(Schema7.Number),
+  client_secret_expires_at: Schema7.optional(Schema7.Number),
+  registration_access_token: Schema7.optional(Schema7.String),
+  registration_client_uri: Schema7.optional(Schema7.String),
+  token_endpoint_auth_method: Schema7.optional(Schema7.String),
+  grant_types: Schema7.optional(StringArray),
+  response_types: Schema7.optional(StringArray),
+  redirect_uris: Schema7.optional(StringArray),
+  client_name: Schema7.optional(Schema7.String),
+  scope: Schema7.optional(Schema7.String)
+}).annotate({ identifier: "OAuthClientInformation" });
+var decodeResourceMetadata = Schema7.decodeUnknownEffect(
+  OAuthProtectedResourceMetadataSchema
+);
+var decodeAuthServerMetadata = Schema7.decodeUnknownEffect(
+  OAuthAuthorizationServerMetadataSchema
+);
+var decodeClientInformation = Schema7.decodeUnknownEffect(
+  OAuthClientInformationSchema
+);
+var MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
+var isLoopbackHttpUrl2 = (value) => {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:") return false;
+    const hostname = url.hostname.toLowerCase();
+    return hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1" || hostname === "[::1]" || hostname.startsWith("127.");
+  } catch {
+    return false;
+  }
+};
+var oauth4webapiOptions = (options, targetUrl) => {
+  const out = {};
+  if (options.fetch) out[customFetch] = options.fetch;
+  if (targetUrl && isLoopbackHttpUrl2(targetUrl)) {
+    out[oauth2.allowInsecureRequests] = true;
+  }
+  const signal = AbortSignal.timeout(options.timeoutMs ?? OAUTH2_DEFAULT_TIMEOUT_MS);
+  out.signal = signal;
+  if (options.mcpProtocolVersion) {
+    out.headers = new Headers({
+      [MCP_PROTOCOL_VERSION_HEADER]: options.mcpProtocolVersion
+    });
+  }
+  return out;
+};
+var customFetch = /* @__PURE__ */ Symbol.for("oauth4webapi.customFetch");
+var buildResourceMetadataUrls = (resourceUrl) => {
+  const url = new URL(resourceUrl);
+  const origin = `${url.protocol}//${url.host}`;
+  const path = url.pathname.replace(/\/+$/, "");
+  const urls = [];
+  if (path && path !== "/") {
+    urls.push(`${origin}/.well-known/oauth-protected-resource${path}`);
+  }
+  urls.push(`${origin}/.well-known/oauth-protected-resource`);
+  return urls;
+};
+var withResourceQueryParams = (url, queryParams) => {
+  if (!queryParams || Object.keys(queryParams).length === 0) return url;
+  const parsed = new URL(url);
+  for (const [key, value] of Object.entries(queryParams)) {
+    parsed.searchParams.set(key, value);
+  }
+  return parsed.toString();
+};
+var discoverProtectedResourceMetadata = (resourceUrl, options = {}) => Effect7.gen(function* () {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const timeoutMs = options.timeoutMs ?? OAUTH2_DEFAULT_TIMEOUT_MS;
+  for (const url of buildResourceMetadataUrls(resourceUrl)) {
+    const result = yield* Effect7.tryPromise({
+      try: async () => {
+        const requestUrl = withResourceQueryParams(url, options.resourceQueryParams);
+        const headers = {
+          ...options.resourceHeaders,
+          accept: "application/json"
+        };
+        if (options.mcpProtocolVersion) {
+          headers[MCP_PROTOCOL_VERSION_HEADER] = options.mcpProtocolVersion;
+        }
+        const response = await fetchImpl(requestUrl, {
+          method: "GET",
+          headers,
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        if (response.status === 404 || response.status === 405) return "skip";
+        if (response.status < 200 || response.status >= 300) {
+          return { status: response.status };
+        }
+        const text = await response.text();
+        if (text.length === 0) return "skip";
+        return { status: response.status, body: JSON.parse(text) };
+      },
+      catch: (cause) => discoveryError(
+        `Failed to fetch ${url}: ${cause instanceof Error ? cause.message : String(cause)}`,
+        { cause }
+      )
+    });
+    if (result === "skip") continue;
+    if (!("body" in result)) {
+      return yield* Effect7.fail(
+        discoveryError(
+          `Protected resource metadata returned status ${result.status}`,
+          { status: result.status }
+        )
+      );
+    }
+    const metadata = yield* decodeResourceMetadata(result.body).pipe(
+      Effect7.mapError(
+        (err) => new OAuthDiscoveryError({
+          message: `Protected resource metadata is malformed: ${Schema7.isSchemaError(err) ? err.message : String(err)}`,
+          cause: err
+        })
+      )
+    );
+    return { metadataUrl: url, metadata };
+  }
+  return null;
+});
+var wellKnownUrlFor = (issuerOrigin, algorithm, issuerPath) => {
+  const suffix = algorithm === "oauth2" ? "oauth-authorization-server" : "openid-configuration";
+  return issuerPath && issuerPath !== "/" ? `${issuerOrigin}/.well-known/${suffix}${issuerPath}` : `${issuerOrigin}/.well-known/${suffix}`;
+};
+var discoverAuthorizationServerMetadata = (issuer, options = {}) => Effect7.gen(function* () {
+  const issuerUrl = new URL(issuer);
+  const issuerOrigin = `${issuerUrl.protocol}//${issuerUrl.host}`;
+  const issuerPath = issuerUrl.pathname.replace(/\/+$/, "");
+  for (const algorithm of ["oauth2", "oidc"]) {
+    const result = yield* Effect7.tryPromise({
+      try: async () => {
+        const response = await oauth2.discoveryRequest(issuerUrl, {
+          algorithm,
+          ...oauth4webapiOptions(options, issuer)
+        });
+        if (response.status === 404 || response.status === 405) {
+          return null;
+        }
+        const as = await oauth2.processDiscoveryResponse(issuerUrl, response);
+        return {
+          metadataUrl: wellKnownUrlFor(issuerOrigin, algorithm, issuerPath),
+          raw: as
+        };
+      },
+      catch: (cause) => {
+        if (cause instanceof OAuthDiscoveryError) return cause;
+        return discoveryError(
+          `Discovery (${algorithm}) failed for ${issuer}: ${cause instanceof Error ? cause.message : String(cause)}`,
+          { cause }
+        );
+      }
+    }).pipe(
+      // If one algorithm fails mid-roundtrip (network, parse, issuer
+      // mismatch) we still want to try the other before giving up.
+      Effect7.result
+    );
+    if (Result.isFailure(result)) continue;
+    if (result.success === null) continue;
+    const metadata = yield* decodeAuthServerMetadata(result.success.raw).pipe(
+      Effect7.mapError(
+        (err) => new OAuthDiscoveryError({
+          message: `Authorization server metadata is malformed: ${Schema7.isSchemaError(err) ? err.message : String(err)}`,
+          cause: err
+        })
+      )
+    );
+    return { metadataUrl: result.success.metadataUrl, metadata };
+  }
+  return null;
+});
+var asForDcr = (registrationEndpoint) => {
+  const url = new URL(registrationEndpoint);
+  return {
+    issuer: `${url.protocol}//${url.host}`,
+    registration_endpoint: registrationEndpoint
+  };
+};
+var registerDynamicClient = (input, options = {}) => Effect7.tryPromise({
+  try: async () => {
+    const as = asForDcr(input.registrationEndpoint);
+    const m = input.metadata;
+    const clientMetadata = {
+      redirect_uris: [...m.redirect_uris]
+    };
+    if (m.client_name !== void 0) clientMetadata.client_name = m.client_name;
+    if (m.grant_types !== void 0) clientMetadata.grant_types = [...m.grant_types];
+    if (m.response_types !== void 0) clientMetadata.response_types = [...m.response_types];
+    if (m.token_endpoint_auth_method !== void 0) {
+      clientMetadata.token_endpoint_auth_method = m.token_endpoint_auth_method;
+    }
+    if (m.scope !== void 0) clientMetadata.scope = m.scope;
+    if (m.application_type !== void 0) clientMetadata.application_type = m.application_type;
+    if (m.client_uri !== void 0) clientMetadata.client_uri = m.client_uri;
+    if (m.logo_uri !== void 0) clientMetadata.logo_uri = m.logo_uri;
+    if (m.contacts !== void 0) clientMetadata.contacts = [...m.contacts];
+    if (m.software_id !== void 0) clientMetadata.software_id = m.software_id;
+    if (m.software_version !== void 0) clientMetadata.software_version = m.software_version;
+    if (m.extra) for (const [k, v] of Object.entries(m.extra)) clientMetadata[k] = v;
+    const reqOptions = oauth4webapiOptions(options);
+    if (isLoopbackHttpUrl2(input.registrationEndpoint)) {
+      reqOptions[oauth2.allowInsecureRequests] = true;
+    }
+    if (input.initialAccessToken) {
+      reqOptions.initialAccessToken = input.initialAccessToken;
+    }
+    const response = await oauth2.dynamicClientRegistrationRequest(
+      as,
+      clientMetadata,
+      reqOptions
+    );
+    const client = await oauth2.processDynamicClientRegistrationResponse(
+      response
+    );
+    return client;
+  },
+  catch: (cause) => {
+    if (cause instanceof oauth2.ResponseBodyError) {
+      return discoveryError(
+        `Dynamic Client Registration failed: ${cause.error}${cause.error_description ? ` \u2014 ${cause.error_description}` : ""}`,
+        { status: cause.status, cause }
+      );
+    }
+    return discoveryError(
+      `Dynamic Client Registration failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+  }
+}).pipe(
+  Effect7.flatMap(
+    (raw) => decodeClientInformation(raw).pipe(
+      Effect7.mapError(
+        (err) => new OAuthDiscoveryError({
+          message: `Dynamic Client Registration response is malformed: ${Schema7.isSchemaError(err) ? err.message : String(err)}`,
+          cause: err
+        })
+      )
+    )
+  )
+);
+var beginDynamicAuthorization = (input, options = {}) => Effect7.gen(function* () {
+  const prior = input.previousState ?? {};
+  const canSkipResourceDiscovery = prior.resourceMetadata !== void 0 || !!prior.authorizationServerUrl || !!prior.authorizationServerMetadata;
+  const resource = canSkipResourceDiscovery ? prior.resourceMetadata ? {
+    metadata: prior.resourceMetadata,
+    metadataUrl: prior.resourceMetadataUrl ?? null
+  } : null : yield* discoverProtectedResourceMetadata(input.endpoint, options);
+  const authorizationServerUrl = (() => {
+    if (prior.authorizationServerUrl) return prior.authorizationServerUrl;
+    const fromResource = resource && resource.metadata.authorization_servers?.[0];
+    if (fromResource) return fromResource;
+    const u = new URL(input.endpoint);
+    return `${u.protocol}//${u.host}`;
+  })();
+  const authServer = prior.authorizationServerMetadata && prior.authorizationServerMetadataUrl ? {
+    metadata: prior.authorizationServerMetadata,
+    metadataUrl: prior.authorizationServerMetadataUrl
+  } : yield* discoverAuthorizationServerMetadata(
+    authorizationServerUrl,
+    options
+  );
+  if (!authServer) {
+    return yield* Effect7.fail(
+      discoveryError(
+        `No OAuth authorization server metadata at ${authorizationServerUrl}`
+      )
+    );
+  }
+  const pkceMethods = authServer.metadata.code_challenge_methods_supported ?? [];
+  if (pkceMethods.length > 0 && !pkceMethods.includes("S256")) {
+    return yield* Effect7.fail(
+      discoveryError(
+        `Authorization server does not support PKCE S256 (advertised: ${pkceMethods.join(", ")})`
+      )
+    );
+  }
+  const responseTypes = authServer.metadata.response_types_supported ?? [];
+  if (responseTypes.length > 0 && !responseTypes.includes("code")) {
+    return yield* Effect7.fail(
+      discoveryError(
+        `Authorization server does not support response_type=code (advertised: ${responseTypes.join(", ")})`
+      )
+    );
+  }
+  const baseClientMetadata = {
+    grant_types: ["authorization_code", "refresh_token"],
+    response_types: ["code"],
+    token_endpoint_auth_method: "none",
+    client_name: "Executor",
+    ...input.clientMetadata ?? {},
+    redirect_uris: input.clientMetadata?.redirect_uris ?? [input.redirectUrl]
+  };
+  const clientInformation = prior.clientInformation ?? (yield* (() => {
+    const reg = authServer.metadata.registration_endpoint;
+    if (!reg) {
+      return Effect7.fail(
+        discoveryError(
+          "Authorization server does not advertise registration_endpoint \u2014 cannot auto-register a client"
+        )
+      );
+    }
+    return registerDynamicClient(
+      { registrationEndpoint: reg, metadata: baseClientMetadata },
+      options
+    );
+  })());
+  const codeVerifier = createPkceCodeVerifier();
+  const codeChallenge = yield* Effect7.promise(
+    () => createPkceCodeChallenge(codeVerifier)
+  );
+  const scopes = input.scopes ?? authServer.metadata.scopes_supported ?? [];
+  const authorizationUrl = buildAuthorizationUrl({
+    authorizationUrl: authServer.metadata.authorization_endpoint,
+    clientId: clientInformation.client_id,
+    redirectUrl: input.redirectUrl,
+    scopes,
+    state: input.state,
+    codeChallenge
+  });
+  return {
+    authorizationUrl,
+    codeVerifier,
+    state: {
+      resourceMetadata: resource?.metadata ?? null,
+      resourceMetadataUrl: resource?.metadataUrl ?? null,
+      authorizationServerUrl,
+      authorizationServerMetadataUrl: authServer.metadataUrl,
+      authorizationServerMetadata: authServer.metadata,
+      clientInformation
+    }
+  };
+});
+
+// src/oauth-service.ts
+import { Effect as Effect8, Schema as Schema8 } from "effect";
+var OAuthAuthorizationServerMetadataJson = Schema8.Record(Schema8.String, Schema8.Unknown);
+var OAuthClientInformationJson = Schema8.Record(Schema8.String, Schema8.Unknown);
+var DynamicDcrSessionPayload = Schema8.Struct({
+  kind: Schema8.Literal("dynamic-dcr"),
+  identityLabel: Schema8.NullOr(Schema8.String),
+  codeVerifier: Schema8.String,
+  authorizationServerUrl: Schema8.String,
+  authorizationServerMetadataUrl: Schema8.String,
+  authorizationServerMetadata: OAuthAuthorizationServerMetadataJson,
+  clientInformation: OAuthClientInformationJson,
+  resourceMetadataUrl: Schema8.NullOr(Schema8.String),
+  resourceMetadata: Schema8.NullOr(
+    Schema8.Record(Schema8.String, Schema8.Unknown)
+  ),
+  scopes: Schema8.Array(Schema8.String)
+});
+var AuthorizationCodeSessionPayload = Schema8.Struct({
+  kind: Schema8.Literal("authorization-code"),
+  identityLabel: Schema8.NullOr(Schema8.String),
+  codeVerifier: Schema8.String,
+  authorizationEndpoint: Schema8.String,
+  tokenEndpoint: Schema8.String,
+  issuerUrl: Schema8.NullOr(Schema8.String).pipe(Schema8.withDecodingDefaultType(Effect8.succeed(null))),
+  clientIdSecretId: Schema8.String,
+  clientSecretSecretId: Schema8.NullOr(Schema8.String),
+  scopes: Schema8.Array(Schema8.String),
+  scopeSeparator: Schema8.optional(Schema8.String),
+  clientAuth: Schema8.Literals(["body", "basic"])
+});
+var OAuthSessionPayload = Schema8.Union([
+  DynamicDcrSessionPayload,
+  AuthorizationCodeSessionPayload
+]);
+var decodeSessionPayload = Schema8.decodeUnknownSync(OAuthSessionPayload);
+var encodeSessionPayload = Schema8.encodeSync(OAuthSessionPayload);
+var coerceJson = (value) => {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+};
+var stringArray = (value) => Array.isArray(value) ? value.filter((scope) => typeof scope === "string") : [];
+var originOrNull = (value) => {
+  if (typeof value !== "string") return null;
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+};
+var decodeProviderState = (value) => {
+  const raw = coerceJson(value);
+  const record = raw && typeof raw === "object" ? raw : null;
+  if (record && !("kind" in record) && "flow" in record && "tokenUrl" in record) {
+    const flow = record.flow;
+    if (flow === "authorizationCode") {
+      return Schema8.decodeUnknownSync(OAuthProviderState)({
+        kind: "authorization-code",
+        tokenEndpoint: record.tokenUrl,
+        issuerUrl: originOrNull(record.authorizationEndpoint),
+        clientIdSecretId: record.clientIdSecretId,
+        clientSecretSecretId: record.clientSecretSecretId ?? null,
+        clientAuth: "body",
+        scope: stringArray(record.scopes).join(" ") || null
+      });
+    }
+    if (flow === "clientCredentials") {
+      return Schema8.decodeUnknownSync(OAuthProviderState)({
+        kind: "client-credentials",
+        tokenEndpoint: record.tokenUrl,
+        clientIdSecretId: record.clientIdSecretId,
+        clientSecretSecretId: record.clientSecretSecretId,
+        scopes: stringArray(record.scopes),
+        clientAuth: "body",
+        scope: stringArray(record.scopes).join(" ") || null
+      });
+    }
+  }
+  if (record && !("kind" in record) && "clientIdSecretId" in record && "scopes" in record) {
+    const scopes = stringArray(record.scopes);
+    return Schema8.decodeUnknownSync(OAuthProviderState)({
+      kind: "authorization-code",
+      tokenEndpoint: "https://oauth2.googleapis.com/token",
+      issuerUrl: "https://accounts.google.com",
+      clientIdSecretId: record.clientIdSecretId,
+      clientSecretSecretId: record.clientSecretSecretId ?? null,
+      clientAuth: "body",
+      scope: scopes.join(" ") || null
+    });
+  }
+  if (record && !("kind" in record) && "clientInformation" in record && "endpoint" in record) {
+    const clientInformation = record.clientInformation && typeof record.clientInformation === "object" ? record.clientInformation : null;
+    return Schema8.decodeUnknownSync(OAuthProviderState)({
+      kind: "dynamic-dcr",
+      tokenEndpoint: typeof record.tokenEndpoint === "string" ? record.tokenEndpoint : record.authorizationServerMetadata && typeof record.authorizationServerMetadata === "object" && typeof record.authorizationServerMetadata.token_endpoint === "string" ? record.authorizationServerMetadata.token_endpoint : "",
+      issuerUrl: record.authorizationServerMetadata && typeof record.authorizationServerMetadata === "object" && typeof record.authorizationServerMetadata.issuer === "string" ? record.authorizationServerMetadata.issuer : null,
+      authorizationServerUrl: typeof record.authorizationServerUrl === "string" ? record.authorizationServerUrl : null,
+      authorizationServerMetadataUrl: typeof record.authorizationServerMetadataUrl === "string" ? record.authorizationServerMetadataUrl : null,
+      clientId: typeof clientInformation?.client_id === "string" ? clientInformation.client_id : "",
+      clientSecretSecretId: null,
+      clientAuth: "body",
+      scope: null
+    });
+  }
+  return Schema8.decodeUnknownSync(OAuthProviderState)(raw);
+};
+var defaultSessionId = () => {
+  const crypto = globalThis.crypto;
+  if (crypto?.randomUUID) return `oauth2_session_${crypto.randomUUID()}`;
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return `oauth2_session_${Array.from(
+    bytes,
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("")}`;
+};
+var secretIdPart = (value) => value.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "oauth";
+var oauthSecretId = (connectionId, suffix) => {
+  const base = secretIdPart(connectionId);
+  const readable = base.length <= 48 ? base : base.slice(0, 40);
+  return `oauth2-${readable}-${suffix}`;
+};
+var scopedSessionId = (scopeId, sessionId) => `${sessionId}_${secretIdPart(scopeId).slice(0, 24)}`;
+var terminalRefreshErrors = /* @__PURE__ */ new Set([
+  "invalid_grant",
+  "invalid_client",
+  "unauthorized_client"
+]);
+var makeOAuth2Service = (deps) => {
+  const now = deps.now ?? (() => Date.now());
+  const newSessionId = deps.newSessionId ?? defaultSessionId;
+  const probe = (input) => Effect8.gen(function* () {
+    const resource = yield* discoverProtectedResourceMetadata(
+      input.endpoint,
+      { resourceHeaders: input.headers, resourceQueryParams: input.queryParams }
+    ).pipe(
+      Effect8.catchTag(
+        "OAuthDiscoveryError",
+        (err) => Effect8.fail(
+          new OAuthProbeError({
+            message: `Protected resource metadata probe failed: ${err.message}`
+          })
+        )
+      )
+    );
+    const authorizationServerUrl = (() => {
+      const fromResource = resource?.metadata.authorization_servers?.[0];
+      if (fromResource) return fromResource;
+      try {
+        const u = new URL(input.endpoint);
+        return `${u.protocol}//${u.host}`;
+      } catch {
+        return null;
+      }
+    })();
+    const authServer = authorizationServerUrl ? yield* discoverAuthorizationServerMetadata(
+      authorizationServerUrl
+    ).pipe(
+      Effect8.catchTag(
+        "OAuthDiscoveryError",
+        () => Effect8.succeed(null)
+      )
+    ) : null;
+    const supportsDynamicRegistration = !!(authServer?.metadata.registration_endpoint && (authServer.metadata.token_endpoint_auth_methods_supported ?? []).includes(
+      "none"
+    ));
+    const isBearerChallengeEndpoint = yield* Effect8.tryPromise({
+      try: async () => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 6e3);
+        try {
+          const probeUrl = new URL(input.endpoint);
+          for (const [key, value] of Object.entries(input.queryParams ?? {})) {
+            probeUrl.searchParams.set(key, value);
+          }
+          const response = await fetch(probeUrl.toString(), {
+            method: "POST",
+            headers: {
+              ...input.headers ?? {},
+              "content-type": "application/json",
+              accept: "application/json, text/event-stream"
+            },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "initialize",
+              params: {
+                protocolVersion: "2025-06-18",
+                capabilities: {},
+                clientInfo: { name: "executor-probe", version: "0" }
+              }
+            }),
+            signal: controller.signal
+          });
+          if (response.status !== 401) return false;
+          const wwwAuth = response.headers.get("www-authenticate") ?? response.headers.get("WWW-Authenticate");
+          return !!wwwAuth && /^\s*bearer\b/i.test(wwwAuth);
+        } finally {
+          clearTimeout(timer);
+        }
+      },
+      catch: () => null
+    }).pipe(Effect8.catch(() => Effect8.succeed(false)));
+    return {
+      resourceMetadata: resource?.metadata ?? null,
+      resourceMetadataUrl: resource?.metadataUrl ?? null,
+      authorizationServerMetadata: authServer?.metadata ?? null,
+      authorizationServerMetadataUrl: authServer?.metadataUrl ?? null,
+      authorizationServerUrl: authorizationServerUrl ?? null,
+      supportsDynamicRegistration,
+      isBearerChallengeEndpoint
+    };
+  });
+  const startDynamicDcr = (input, strategy) => Effect8.gen(function* () {
+    const started = yield* beginDynamicAuthorization({
+      endpoint: input.endpoint,
+      redirectUrl: input.redirectUrl,
+      state: "",
+      scopes: strategy.scopes
+    }, {
+      resourceHeaders: input.headers,
+      resourceQueryParams: input.queryParams
+    }).pipe(
+      Effect8.catchTag(
+        "OAuthDiscoveryError",
+        (err) => Effect8.fail(
+          new OAuthStartError({
+            message: `Dynamic authorization setup failed: ${err.message}`
+          })
+        )
+      )
+    );
+    const sessionId = scopedSessionId(input.tokenScope, newSessionId());
+    const codeChallenge = yield* Effect8.promise(
+      () => createPkceCodeChallenge(started.codeVerifier)
+    );
+    const authorizationUrl = buildAuthorizationUrl({
+      authorizationUrl: started.state.authorizationServerMetadata.authorization_endpoint,
+      clientId: started.state.clientInformation.client_id,
+      redirectUrl: input.redirectUrl,
+      scopes: strategy.scopes ?? started.state.authorizationServerMetadata.scopes_supported ?? [],
+      state: sessionId,
+      codeChallenge
+    });
+    const payload = {
+      kind: "dynamic-dcr",
+      identityLabel: input.identityLabel ?? null,
+      codeVerifier: started.codeVerifier,
+      authorizationServerUrl: started.state.authorizationServerUrl,
+      authorizationServerMetadataUrl: started.state.authorizationServerMetadataUrl,
+      authorizationServerMetadata: started.state.authorizationServerMetadata,
+      clientInformation: (() => {
+        const value = started.state.clientInformation;
+        return value;
+      })(),
+      resourceMetadataUrl: started.state.resourceMetadataUrl,
+      resourceMetadata: started.state.resourceMetadata ?? null,
+      scopes: [
+        ...strategy.scopes ?? started.state.authorizationServerMetadata.scopes_supported ?? []
+      ]
+    };
+    yield* writeSession({
+      sessionId,
+      input,
+      payload,
+      strategyKind: "dynamic-dcr"
+    });
+    return {
+      sessionId,
+      authorizationUrl,
+      completedConnection: null
+    };
+  });
+  const startAuthorizationCode = (input, strategy) => Effect8.gen(function* () {
+    const clientId = yield* deps.secretsGet(strategy.clientIdSecretId).pipe(
+      Effect8.mapError(
+        (err) => (
+          // Storage failure propagates; null returns aren't errors — the
+          // branch below handles them.
+          err
+        )
+      )
+    );
+    if (clientId === null) {
+      return yield* Effect8.fail(
+        new OAuthStartError({
+          message: `client_id secret "${strategy.clientIdSecretId}" not found`
+        })
+      );
+    }
+    const sessionId = scopedSessionId(input.tokenScope, newSessionId());
+    const codeVerifier = createPkceCodeVerifier();
+    const codeChallenge = yield* Effect8.promise(
+      () => createPkceCodeChallenge(codeVerifier)
+    );
+    const authorizationUrl = buildAuthorizationUrl({
+      authorizationUrl: strategy.authorizationEndpoint,
+      clientId,
+      redirectUrl: input.redirectUrl,
+      scopes: strategy.scopes,
+      state: sessionId,
+      codeChallenge,
+      scopeSeparator: strategy.scopeSeparator,
+      extraParams: strategy.extraAuthorizationParams
+    });
+    const payload = {
+      kind: "authorization-code",
+      identityLabel: input.identityLabel ?? null,
+      codeVerifier,
+      authorizationEndpoint: strategy.authorizationEndpoint,
+      tokenEndpoint: strategy.tokenEndpoint,
+      issuerUrl: strategy.issuerUrl ?? new URL(strategy.authorizationEndpoint).origin,
+      clientIdSecretId: strategy.clientIdSecretId,
+      clientSecretSecretId: strategy.clientSecretSecretId,
+      scopes: [...strategy.scopes],
+      scopeSeparator: strategy.scopeSeparator,
+      clientAuth: strategy.clientAuth ?? "body"
+    };
+    yield* writeSession({
+      sessionId,
+      input,
+      payload,
+      strategyKind: "authorization-code"
+    });
+    return {
+      sessionId,
+      authorizationUrl,
+      completedConnection: null
+    };
+  });
+  const startClientCredentials = (input, strategy) => Effect8.gen(function* () {
+    const clientId = yield* deps.secretsGet(strategy.clientIdSecretId);
+    const clientSecret = yield* deps.secretsGet(strategy.clientSecretSecretId);
+    if (clientId === null || clientSecret === null) {
+      return yield* Effect8.fail(
+        new OAuthStartError({
+          message: "client_id / client_secret secret not found"
+        })
+      );
+    }
+    const tokens = yield* exchangeClientCredentials({
+      tokenUrl: strategy.tokenEndpoint,
+      clientId,
+      clientSecret,
+      scopes: strategy.scopes,
+      scopeSeparator: strategy.scopeSeparator,
+      clientAuth: strategy.clientAuth ?? "body"
+    }).pipe(
+      Effect8.mapError(
+        (err) => new OAuthStartError({
+          message: `Client credentials exchange failed: ${err.message}`
+        })
+      )
+    );
+    const expiresAt = typeof tokens.expires_in === "number" ? now() + tokens.expires_in * 1e3 : null;
+    const providerState = {
+      kind: "client-credentials",
+      tokenEndpoint: strategy.tokenEndpoint,
+      clientIdSecretId: strategy.clientIdSecretId,
+      clientSecretSecretId: strategy.clientSecretSecretId,
+      scopes: [...strategy.scopes ?? []],
+      scopeSeparator: strategy.scopeSeparator,
+      clientAuth: strategy.clientAuth ?? "body",
+      scope: tokens.scope ?? null
+    };
+    yield* deps.connectionsCreate(
+      new CreateConnectionInput({
+        id: ConnectionId.make(input.connectionId),
+        scope: ScopeId.make(input.tokenScope),
+        provider: OAUTH2_PROVIDER_KEY,
+        identityLabel: input.identityLabel ?? safeHostname(input.endpoint),
+        accessToken: new TokenMaterial({
+          secretId: SecretId.make(oauthSecretId(input.connectionId, "access-token")),
+          name: "OAuth Access Token",
+          value: tokens.access_token
+        }),
+        refreshToken: null,
+        expiresAt,
+        oauthScope: tokens.scope ?? null,
+        providerState: Schema8.encodeSync(OAuthProviderState)(
+          providerState
+        )
+      })
+    ).pipe(
+      Effect8.mapError(
+        (err) => new OAuthStartError({
+          message: `Failed to mint connection: ${err instanceof Error ? err.message : String(err)}`
+        })
+      )
+    );
+    return {
+      sessionId: "",
+      authorizationUrl: null,
+      completedConnection: { connectionId: input.connectionId }
+    };
+  });
+  const start = (input) => {
+    switch (input.strategy.kind) {
+      case "dynamic-dcr":
+        return startDynamicDcr(input, input.strategy);
+      case "authorization-code":
+        return startAuthorizationCode(input, input.strategy);
+      case "client-credentials":
+        return startClientCredentials(input, input.strategy);
+    }
+  };
+  const writeSession = (args) => deps.adapter.create({
+    model: "oauth2_session",
+    data: {
+      id: args.sessionId,
+      scope_id: args.input.tokenScope,
+      plugin_id: args.input.pluginId,
+      strategy: args.strategyKind,
+      connection_id: args.input.connectionId,
+      token_scope: args.input.tokenScope,
+      redirect_url: args.input.redirectUrl,
+      payload: encodeSessionPayload(args.payload),
+      expires_at: now() + OAUTH2_SESSION_TTL_MS,
+      created_at: /* @__PURE__ */ new Date()
+    },
+    forceAllowId: true
+  }).pipe(Effect8.asVoid);
+  const complete = (input) => Effect8.gen(function* () {
+    const row = yield* deps.adapter.findOne({
+      model: "oauth2_session",
+      where: [{ field: "id", value: input.state }]
+    });
+    if (!row) {
+      return yield* Effect8.fail(
+        new OAuthSessionNotFoundError({ sessionId: input.state })
+      );
+    }
+    const deleteSession = deps.adapter.delete({
+      model: "oauth2_session",
+      where: [
+        { field: "id", value: input.state },
+        { field: "scope_id", value: row.scope_id }
+      ]
+    });
+    if (input.error) {
+      yield* deleteSession;
+      return yield* Effect8.fail(
+        new OAuthCompleteError({
+          message: `Authorization server returned error: ${input.error}`,
+          code: input.error
+        })
+      );
+    }
+    if (!input.code) {
+      yield* deleteSession;
+      return yield* Effect8.fail(
+        new OAuthCompleteError({
+          message: "Missing authorization code"
+        })
+      );
+    }
+    const expiresAt = Number(row.expires_at);
+    if (expiresAt <= now()) {
+      yield* deleteSession;
+      return yield* Effect8.fail(
+        new OAuthCompleteError({
+          message: "OAuth session expired"
+        })
+      );
+    }
+    const payload = decodeSessionPayload(coerceJson(row.payload));
+    const endpoint = "";
+    const connectionId = row.connection_id;
+    const tokenScope = row.token_scope;
+    const redirectUrl = row.redirect_url;
+    const exchangeResult = yield* (() => {
+      switch (payload.kind) {
+        case "dynamic-dcr":
+          return exchangeDynamicDcr(payload, input.code, redirectUrl);
+        case "authorization-code":
+          return exchangeAuthorizationCodeStrategy(
+            payload,
+            input.code,
+            redirectUrl
+          );
+      }
+    })().pipe(Effect8.tapError(() => deleteSession));
+    const connectionExpiresAt = typeof exchangeResult.tokens.expires_in === "number" ? now() + exchangeResult.tokens.expires_in * 1e3 : null;
+    const dynamicClientSecretSecretId = yield* (() => {
+      if (payload.kind !== "dynamic-dcr") return Effect8.succeed(null);
+      const clientSecret = payload.clientInformation.client_secret;
+      if (typeof clientSecret !== "string" || clientSecret.length === 0) {
+        return Effect8.succeed(null);
+      }
+      const secretId = oauthSecretId(connectionId, "client-secret");
+      return deps.secretsSet(
+        new SetSecretInput({
+          id: SecretId.make(secretId),
+          scope: ScopeId.make(tokenScope),
+          name: "OAuth Client Secret",
+          value: clientSecret
+        })
+      ).pipe(
+        Effect8.as(secretId),
+        Effect8.mapError(
+          (err) => new OAuthCompleteError({
+            message: `Failed to persist DCR client_secret: ${err instanceof Error ? err.message : String(err)}`
+          })
+        )
+      );
+    })();
+    const providerState = payload.kind === "dynamic-dcr" ? {
+      kind: "dynamic-dcr",
+      tokenEndpoint: payload.authorizationServerMetadata.token_endpoint,
+      issuerUrl: payload.authorizationServerMetadata.issuer ?? null,
+      authorizationServerUrl: payload.authorizationServerUrl,
+      authorizationServerMetadataUrl: payload.authorizationServerMetadataUrl,
+      idTokenSigningAlgValuesSupported: payload.authorizationServerMetadata.id_token_signing_alg_values_supported,
+      clientId: payload.clientInformation.client_id,
+      clientSecretSecretId: dynamicClientSecretSecretId,
+      clientAuth: payload.clientInformation.token_endpoint_auth_method === "client_secret_basic" ? "basic" : "body",
+      scopes: [...payload.scopes],
+      scope: exchangeResult.tokens.scope ?? null
+    } : {
+      kind: "authorization-code",
+      tokenEndpoint: payload.tokenEndpoint,
+      issuerUrl: payload.issuerUrl,
+      clientIdSecretId: payload.clientIdSecretId,
+      clientSecretSecretId: payload.clientSecretSecretId,
+      clientAuth: payload.clientAuth,
+      scopes: [...payload.scopes],
+      scopeSeparator: payload.scopeSeparator,
+      scope: exchangeResult.tokens.scope ?? null
+    };
+    yield* deps.connectionsCreate(
+      new CreateConnectionInput({
+        id: ConnectionId.make(connectionId),
+        scope: ScopeId.make(tokenScope),
+        provider: OAUTH2_PROVIDER_KEY,
+        identityLabel: safeHostname(
+          payload.identityLabel ?? exchangeResult.endpointForDisplay ?? endpoint
+        ),
+        accessToken: new TokenMaterial({
+          secretId: SecretId.make(oauthSecretId(connectionId, "access-token")),
+          name: "OAuth Access Token",
+          value: exchangeResult.tokens.access_token
+        }),
+        refreshToken: exchangeResult.tokens.refresh_token ? new TokenMaterial({
+          secretId: SecretId.make(oauthSecretId(connectionId, "refresh-token")),
+          name: "OAuth Refresh Token",
+          value: exchangeResult.tokens.refresh_token
+        }) : null,
+        expiresAt: connectionExpiresAt,
+        oauthScope: exchangeResult.tokens.scope ?? null,
+        providerState: Schema8.encodeSync(OAuthProviderState)(
+          providerState
+        )
+      })
+    ).pipe(
+      Effect8.mapError(
+        (err) => new OAuthCompleteError({
+          message: `Failed to mint connection: ${err instanceof Error ? err.message : String(err)}`
+        })
+      )
+    );
+    yield* deleteSession;
+    return {
+      connectionId,
+      expiresAt: connectionExpiresAt,
+      scope: exchangeResult.tokens.scope ?? null
+    };
+  });
+  const exchangeDynamicDcr = (payload, code, redirectUrl) => Effect8.gen(function* () {
+    const md = payload.authorizationServerMetadata;
+    const ci = payload.clientInformation;
+    const tokens = yield* exchangeAuthorizationCode({
+      tokenUrl: md.token_endpoint,
+      issuerUrl: md.issuer,
+      clientId: ci.client_id,
+      clientSecret: ci.client_secret ?? void 0,
+      redirectUrl,
+      codeVerifier: payload.codeVerifier,
+      code,
+      idTokenSigningAlgValuesSupported: md.id_token_signing_alg_values_supported,
+      clientAuth: ci.token_endpoint_auth_method === "client_secret_basic" ? "basic" : "body"
+    }).pipe(
+      Effect8.mapError(
+        (err) => new OAuthCompleteError({
+          message: `Token exchange failed: ${err.message}`,
+          code: err.error
+        })
+      )
+    );
+    return {
+      tokens,
+      endpointForDisplay: payload.authorizationServerUrl
+    };
+  });
+  const exchangeAuthorizationCodeStrategy = (payload, code, redirectUrl) => Effect8.gen(function* () {
+    const clientId = yield* deps.secretsGet(payload.clientIdSecretId);
+    if (clientId === null) {
+      return yield* Effect8.fail(
+        new OAuthCompleteError({
+          message: `client_id secret "${payload.clientIdSecretId}" not found`
+        })
+      );
+    }
+    const clientSecret = payload.clientSecretSecretId ? yield* deps.secretsGet(payload.clientSecretSecretId) : null;
+    if (payload.clientSecretSecretId && clientSecret === null) {
+      return yield* Effect8.fail(
+        new OAuthCompleteError({
+          message: `client_secret secret "${payload.clientSecretSecretId}" not found`
+        })
+      );
+    }
+    const tokens = yield* exchangeAuthorizationCode({
+      tokenUrl: payload.tokenEndpoint,
+      issuerUrl: payload.issuerUrl,
+      clientId,
+      clientSecret: clientSecret ?? void 0,
+      redirectUrl,
+      codeVerifier: payload.codeVerifier,
+      code,
+      clientAuth: payload.clientAuth
+    }).pipe(
+      Effect8.mapError(
+        (err) => new OAuthCompleteError({
+          message: `Token exchange failed: ${err.message}`,
+          code: err.error
+        })
+      )
+    );
+    return {
+      tokens,
+      endpointForDisplay: null
+    };
+  });
+  const cancel = (sessionId) => Effect8.gen(function* () {
+    const row = yield* deps.adapter.findOne({
+      model: "oauth2_session",
+      where: [{ field: "id", value: sessionId }]
+    });
+    if (!row) return;
+    yield* deps.adapter.delete({
+      model: "oauth2_session",
+      where: [
+        { field: "id", value: sessionId },
+        { field: "scope_id", value: row.scope_id }
+      ]
+    });
+  });
+  const connectionProvider = {
+    key: OAUTH2_PROVIDER_KEY,
+    refresh: (input) => Effect8.gen(function* () {
+      if (!input.providerState) {
+        return yield* new ConnectionRefreshError({
+          connectionId: input.connectionId,
+          message: "oauth2 connection missing providerState"
+        });
+      }
+      const state = yield* Effect8.try({
+        try: () => decodeProviderState(input.providerState),
+        catch: (cause) => new ConnectionRefreshError({
+          connectionId: input.connectionId,
+          message: `oauth2 providerState is malformed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          cause
+        })
+      });
+      if (state.kind !== "client-credentials" && !input.refreshToken) {
+        return yield* new ConnectionRefreshError({
+          connectionId: input.connectionId,
+          message: "oauth2 connection has no refresh token",
+          reauthRequired: true
+        });
+      }
+      const { clientId, clientSecret } = yield* (() => {
+        switch (state.kind) {
+          case "dynamic-dcr":
+            return Effect8.gen(function* () {
+              const csec = state.clientSecretSecretId ? yield* deps.secretsGet(state.clientSecretSecretId).pipe(
+                Effect8.mapError(
+                  (cause) => new ConnectionRefreshError({
+                    connectionId: input.connectionId,
+                    message: `Failed to resolve DCR client_secret: ${cause instanceof Error ? cause.message : String(cause)}`,
+                    cause
+                  })
+                )
+              ) : null;
+              if (state.clientSecretSecretId && csec === null) {
+                return yield* new ConnectionRefreshError({
+                  connectionId: input.connectionId,
+                  message: `client_secret secret "${state.clientSecretSecretId}" not found`,
+                  reauthRequired: true
+                });
+              }
+              return { clientId: state.clientId, clientSecret: csec };
+            });
+          case "authorization-code":
+          case "client-credentials":
+            return Effect8.gen(function* () {
+              const cid = yield* deps.secretsGet(state.clientIdSecretId).pipe(
+                Effect8.mapError(
+                  (cause) => new ConnectionRefreshError({
+                    connectionId: input.connectionId,
+                    message: `Failed to resolve client_id secret: ${cause instanceof Error ? cause.message : String(cause)}`,
+                    cause
+                  })
+                )
+              );
+              if (cid === null) {
+                return yield* new ConnectionRefreshError({
+                  connectionId: input.connectionId,
+                  message: `client_id secret "${state.clientIdSecretId}" not found`,
+                  reauthRequired: true
+                });
+              }
+              const csec = state.clientSecretSecretId ? yield* deps.secretsGet(state.clientSecretSecretId).pipe(
+                Effect8.mapError(
+                  (cause) => new ConnectionRefreshError({
+                    connectionId: input.connectionId,
+                    message: `Failed to resolve client_secret: ${cause instanceof Error ? cause.message : String(cause)}`,
+                    cause
+                  })
+                )
+              ) : null;
+              if (state.clientSecretSecretId && csec === null) {
+                return yield* new ConnectionRefreshError({
+                  connectionId: input.connectionId,
+                  message: `client_secret secret "${state.clientSecretSecretId}" not found`,
+                  reauthRequired: true
+                });
+              }
+              return { clientId: cid, clientSecret: csec };
+            });
+        }
+      })();
+      const tokenEndpoint = yield* (() => {
+        if (state.tokenEndpoint) return Effect8.succeed(state.tokenEndpoint);
+        if (state.kind === "dynamic-dcr" && state.authorizationServerUrl) {
+          return discoverAuthorizationServerMetadata(
+            state.authorizationServerUrl
+          ).pipe(
+            Effect8.flatMap(
+              (metadata) => metadata?.metadata.token_endpoint ? Effect8.succeed(metadata.metadata.token_endpoint) : Effect8.fail(
+                new ConnectionRefreshError({
+                  connectionId: input.connectionId,
+                  message: "oauth2 legacy MCP providerState is missing token endpoint",
+                  reauthRequired: true
+                })
+              )
+            ),
+            Effect8.mapError(
+              (cause) => cause instanceof ConnectionRefreshError ? cause : new ConnectionRefreshError({
+                connectionId: input.connectionId,
+                message: "Failed to discover token endpoint for legacy MCP OAuth connection",
+                reauthRequired: true,
+                cause
+              })
+            )
+          );
+        }
+        return Effect8.fail(
+          new ConnectionRefreshError({
+            connectionId: input.connectionId,
+            message: "oauth2 providerState is missing token endpoint",
+            reauthRequired: true
+          })
+        );
+      })();
+      const tokens = yield* (state.kind === "client-credentials" ? exchangeClientCredentials({
+        tokenUrl: tokenEndpoint,
+        clientId,
+        clientSecret: clientSecret ?? "",
+        scopes: state.scopes,
+        scopeSeparator: state.scopeSeparator,
+        clientAuth: state.clientAuth
+      }) : refreshAccessToken({
+        tokenUrl: tokenEndpoint,
+        issuerUrl: state.kind === "dynamic-dcr" || state.kind === "authorization-code" ? state.issuerUrl ?? void 0 : void 0,
+        clientId,
+        clientSecret: clientSecret ?? void 0,
+        refreshToken: input.refreshToken,
+        scopes: state.kind === "dynamic-dcr" || state.kind === "authorization-code" ? state.scopes : void 0,
+        scopeSeparator: state.kind === "dynamic-dcr" || state.kind === "authorization-code" ? state.scopeSeparator : void 0,
+        clientAuth: state.clientAuth,
+        idTokenSigningAlgValuesSupported: state.kind === "dynamic-dcr" ? state.idTokenSigningAlgValuesSupported : void 0
+      })).pipe(
+        Effect8.mapError(
+          (err) => new ConnectionRefreshError({
+            connectionId: input.connectionId,
+            message: `OAuth refresh failed: ${err.message}`,
+            // Terminal RFC 6749 §5.2 errors mean retrying won't heal it.
+            reauthRequired: err.error ? terminalRefreshErrors.has(err.error) : false
+          })
+        )
+      );
+      const expiresAt = typeof tokens.expires_in === "number" ? now() + tokens.expires_in * 1e3 : null;
+      const result = {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt,
+        oauthScope: tokens.scope ?? input.oauthScope,
+        providerState: Schema8.encodeSync(OAuthProviderState)({
+          ...state,
+          tokenEndpoint,
+          scope: tokens.scope ?? state.scope
+        })
+      };
+      return result;
+    })
+  };
+  const service = { probe, start, complete, cancel };
+  return { service, connectionProvider };
+};
+var safeHostname = (value) => {
+  if (!value) return null;
+  try {
+    return new URL(value).host;
+  } catch {
+    return value;
+  }
+};
+
+// src/policies.ts
+import { Schema as Schema9 } from "effect";
+var matchPattern = (pattern, toolId) => {
+  if (pattern === "*") return true;
+  if (pattern === toolId) return true;
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    if (prefix.length === 0) return false;
+    return toolId === prefix || toolId.startsWith(`${prefix}.`);
+  }
+  return false;
+};
+var isValidPattern = (pattern) => {
+  if (pattern.length === 0) return false;
+  if (pattern === "*") return true;
+  if (pattern.startsWith(".") || pattern.endsWith(".")) return false;
+  if (pattern.includes("..")) return false;
+  if (pattern.startsWith("*")) return false;
+  const segments = pattern.split(".");
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.length === 0) return false;
+    if (seg.includes("*") && seg !== "*") return false;
+    if (seg === "*" && i !== segments.length - 1) return false;
+  }
+  return true;
+};
+var comparePolicyRow = (a, b) => {
+  const pa = a.position;
+  const pb = b.position;
+  if (pa < pb) return -1;
+  if (pa > pb) return 1;
+  const ia = a.id;
+  const ib = b.id;
+  return ia < ib ? -1 : ia > ib ? 1 : 0;
+};
+var resolveToolPolicy = (toolId, policies, scopeRank) => {
+  if (policies.length === 0) return void 0;
+  const sorted = [...policies].sort((a, b) => {
+    const sa = scopeRank(a);
+    const sb = scopeRank(b);
+    if (sa !== sb) return sa - sb;
+    return comparePolicyRow(a, b);
+  });
+  for (const row of sorted) {
+    if (matchPattern(row.pattern, toolId)) {
+      return {
+        action: row.action,
+        pattern: row.pattern,
+        policyId: row.id
+      };
+    }
+  }
+  return void 0;
+};
+var liftPlugin = (defaultRequiresApproval) => defaultRequiresApproval ? { action: "require_approval", source: "plugin-default" } : { action: "approve", source: "plugin-default" };
+var liftUser = (match) => ({
+  action: match.action,
+  source: "user",
+  pattern: match.pattern,
+  policyId: match.policyId
+});
+var resolveEffectivePolicy = (toolId, policies, scopeRank, defaultRequiresApproval) => {
+  const match = resolveToolPolicy(toolId, policies, scopeRank);
+  return match ? liftUser(match) : liftPlugin(defaultRequiresApproval);
+};
+var effectivePolicyFromSorted = (toolId, sortedPolicies, defaultRequiresApproval) => {
+  for (const p of sortedPolicies) {
+    if (matchPattern(p.pattern, toolId)) {
+      return {
+        action: p.action,
+        source: "user",
+        pattern: p.pattern,
+        policyId: p.id
+      };
+    }
+  }
+  return liftPlugin(defaultRequiresApproval);
+};
+var rowToToolPolicy = (row) => ({
+  id: PolicyId.make(row.id),
+  scopeId: ScopeId.make(row.scope_id),
+  pattern: row.pattern,
+  action: row.action,
+  position: row.position,
+  createdAt: row.created_at,
+  updatedAt: row.updated_at
+});
+var ToolPolicyActionSchema = Schema9.Literals([
+  "approve",
+  "require_approval",
+  "block"
+]);
+
+// src/types.ts
+import { Schema as Schema10 } from "effect";
+var ToolSchema = class extends Schema10.Class("ToolSchema")({
+  id: ToolId,
+  name: Schema10.optional(Schema10.String),
+  description: Schema10.optional(Schema10.String),
+  inputSchema: Schema10.optional(Schema10.Unknown),
+  outputSchema: Schema10.optional(Schema10.Unknown),
+  inputTypeScript: Schema10.optional(Schema10.String),
+  outputTypeScript: Schema10.optional(Schema10.String),
+  typeScriptDefinitions: Schema10.optional(
+    Schema10.Record(Schema10.String, Schema10.String)
+  )
+}) {
+};
+var SourceDetectionResult = class extends Schema10.Class(
+  "SourceDetectionResult"
+)({
+  /** Plugin id that recognized the URL (e.g. "openapi", "graphql"). */
+  kind: Schema10.String,
+  /** Confidence tier — UI uses this to pick a winner when multiple
+   *  plugins claim a URL. */
+  confidence: Schema10.Literals(["high", "medium", "low"]),
+  /** The (possibly normalized) endpoint the plugin will use. */
+  endpoint: Schema10.String,
+  /** Human-readable name suggestion, typically derived from spec title
+   *  or URL hostname. */
+  name: Schema10.String,
+  /** Namespace suggestion — the plugin's recommendation for the source
+   *  id. UI may override. */
+  namespace: Schema10.String
+}) {
+};
+
+// src/schema-types.ts
+var VALID_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var REF_PATTERN = /^#\/(?:\$defs|definitions)\/(.+)$/;
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+var asStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+var truncate = (value, maxLength) => value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 4))} ...`;
+var formatPropertyKey = (value) => VALID_IDENTIFIER_PATTERN.test(value) ? value : JSON.stringify(value);
+var refNameFromPointer = (ref) => ref.match(REF_PATTERN)?.[1];
+var refFallbackLabel = (ref) => refNameFromPointer(ref) ?? ref.split("/").at(-1) ?? ref;
+var summarizeLargeComposite = (schema, maxCompositeMembers) => {
+  for (const kind of ["oneOf", "anyOf"]) {
+    const items = schema[kind];
+    if (Array.isArray(items) && items.length > maxCompositeMembers) {
+      return { kind, count: items.length };
+    }
+  }
+  return null;
+};
+var primitiveTypeName = (value) => {
+  switch (value) {
+    case "integer":
+    case "number":
+      return "number";
+    case "string":
+    case "boolean":
+    case "null":
+      return value;
+    case "array":
+      return "unknown[]";
+    case "object":
+      return "Record<string, unknown>";
+    default:
+      return "unknown";
+  }
+};
+var renderComposite = (input) => {
+  const rawItems = input.schema[input.key];
+  const items = Array.isArray(rawItems) ? rawItems.map((item) => asRecord(item)) : [];
+  if (items.length === 0) {
+    return null;
+  }
+  const labels = items.map((item) => input.render(item, input.depthRemaining - 1)).filter((label) => label.length > 0);
+  if (labels.length === 0) {
+    return null;
+  }
+  return labels.join(input.key === "allOf" ? " & " : " | ");
+};
+var localDefinitionsFromSchema = (schema) => {
+  const root = asRecord(schema);
+  const defs = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(asRecord(root.$defs))) {
+    defs.set(key, value);
+  }
+  for (const [key, value] of Object.entries(asRecord(root.definitions))) {
+    defs.set(key, value);
+  }
+  return defs;
+};
+var schemaToTypeScriptPreview = (schema, options = {}) => {
+  const localDefs = localDefinitionsFromSchema(schema);
+  return schemaToTypeScriptPreviewWithDefs(schema, localDefs, options);
+};
+var schemaToTypeScriptPreviewWithDefs = (schema, defs, options = {}) => {
+  const maxLength = options.maxLength ?? 400;
+  const maxDepth = options.maxDepth ?? 6;
+  const maxProperties = options.maxProperties ?? 12;
+  const maxRefDepth = options.maxRefDepth ?? 3;
+  const maxCompositeMembers = options.maxCompositeMembers ?? 8;
+  const render = (input) => {
+    const current = asRecord(input.currentInput);
+    if (input.depthRemaining <= 0) {
+      if (typeof current.title === "string" && current.title.length > 0) {
+        return current.title;
+      }
+      if (current.type === "array") {
+        return "unknown[]";
+      }
+      if (current.type === "object" || current.properties) {
+        return "Record<string, unknown>";
+      }
+      return "unknown";
+    }
+    if (typeof current.$ref === "string") {
+      const refLabel = refFallbackLabel(current.$ref);
+      return input.refDepthRemaining > 0 ? refLabel : `unknown /* ${refLabel} omitted */`;
+    }
+    if ("const" in current) {
+      return JSON.stringify(current.const);
+    }
+    const enumValues = Array.isArray(current.enum) ? current.enum : [];
+    if (enumValues.length > 0) {
+      return truncate(enumValues.map((value) => JSON.stringify(value)).join(" | "), maxLength);
+    }
+    const largeComposite = summarizeLargeComposite(current, maxCompositeMembers);
+    if (largeComposite) {
+      return `unknown /* ${largeComposite.count}-way ${largeComposite.kind} omitted */`;
+    }
+    const renderNested = (value) => render({
+      currentInput: value,
+      depthRemaining: input.depthRemaining - 1,
+      refDepthRemaining: input.refDepthRemaining
+    });
+    const composite = renderComposite({
+      key: "oneOf",
+      schema: current,
+      render: (value) => renderNested(value),
+      depthRemaining: input.depthRemaining
+    }) ?? renderComposite({
+      key: "anyOf",
+      schema: current,
+      render: (value) => renderNested(value),
+      depthRemaining: input.depthRemaining
+    }) ?? renderComposite({
+      key: "allOf",
+      schema: current,
+      render: (value) => renderNested(value),
+      depthRemaining: input.depthRemaining
+    });
+    if (composite) {
+      return truncate(composite, maxLength);
+    }
+    if (current.nullable === true) {
+      const { nullable: _nullable, ...rest } = current;
+      return truncate(
+        `${render({
+          currentInput: rest,
+          depthRemaining: input.depthRemaining,
+          refDepthRemaining: input.refDepthRemaining
+        })} | null`,
+        maxLength
+      );
+    }
+    if (current.type === "array") {
+      const itemLabel = current.items ? render({
+        currentInput: current.items,
+        depthRemaining: input.depthRemaining - 1,
+        refDepthRemaining: input.refDepthRemaining
+      }) : "unknown";
+      return truncate(`${itemLabel}[]`, maxLength);
+    }
+    if (current.type === "object" || current.properties) {
+      const properties = asRecord(current.properties);
+      const propertyKeys = Object.keys(properties);
+      const required = new Set(asStringArray(current.required));
+      const additionalProperties = current.additionalProperties;
+      const additionalPropertiesLabel = additionalProperties && typeof additionalProperties === "object" ? render({
+        currentInput: additionalProperties,
+        depthRemaining: input.depthRemaining - 1,
+        refDepthRemaining: input.refDepthRemaining
+      }) : additionalProperties === true ? "unknown" : null;
+      if (propertyKeys.length === 0) {
+        if (additionalPropertiesLabel) {
+          return truncate(`Record<string, ${additionalPropertiesLabel}>`, maxLength);
+        }
+        return "Record<string, unknown>";
+      }
+      const visibleKeys = propertyKeys.slice(0, maxProperties);
+      const parts = visibleKeys.map(
+        (key) => `${formatPropertyKey(key)}${required.has(key) ? "" : "?"}: ${render({
+          currentInput: properties[key],
+          depthRemaining: input.depthRemaining - 1,
+          refDepthRemaining: input.refDepthRemaining
+        })}`
+      );
+      if (visibleKeys.length < propertyKeys.length) {
+        parts.push("...");
+      }
+      if (additionalPropertiesLabel) {
+        parts.push(`[key: string]: ${additionalPropertiesLabel}`);
+      }
+      return truncate(`{ ${parts.join("; ")} }`, maxLength);
+    }
+    if (Array.isArray(current.type)) {
+      return truncate(
+        current.type.filter((value) => typeof value === "string").map(primitiveTypeName).join(" | "),
+        maxLength
+      );
+    }
+    if (typeof current.type === "string") {
+      return primitiveTypeName(current.type);
+    }
+    return "unknown";
+  };
+  const referencedDepths = /* @__PURE__ */ new Map();
+  const collectPreviewRefs = (currentInput, refDepth) => {
+    const current = asRecord(currentInput);
+    if (summarizeLargeComposite(current, maxCompositeMembers)) {
+      return;
+    }
+    if (typeof current.$ref === "string") {
+      const name = refNameFromPointer(current.$ref);
+      if (!name) {
+        return;
+      }
+      const existingDepth = referencedDepths.get(name);
+      if (existingDepth !== void 0 && existingDepth <= refDepth) {
+        return;
+      }
+      referencedDepths.set(name, refDepth);
+      if (refDepth >= maxRefDepth) {
+        return;
+      }
+      const target = defs.get(name);
+      if (target !== void 0) {
+        collectPreviewRefs(target, refDepth + 1);
+      }
+      return;
+    }
+    for (const value of Object.values(current)) {
+      if (value && typeof value === "object") {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            collectPreviewRefs(item, refDepth);
+          }
+        } else {
+          collectPreviewRefs(value, refDepth);
+        }
+      }
+    }
+  };
+  collectPreviewRefs(schema, 1);
+  const definitions = Object.fromEntries(
+    [...referencedDepths.entries()].sort(([left], [right]) => left.localeCompare(right)).flatMap(([name, refDepth]) => {
+      const target = defs.get(name);
+      if (target === void 0) {
+        return [];
+      }
+      return [
+        [
+          name,
+          render({
+            currentInput: target,
+            depthRemaining: maxDepth,
+            refDepthRemaining: Math.max(0, maxRefDepth - refDepth)
+          })
+        ]
+      ];
+    })
+  );
+  return {
+    type: render({
+      currentInput: schema,
+      depthRemaining: maxDepth,
+      refDepthRemaining: maxRefDepth
+    }),
+    definitions
+  };
+};
+var buildToolTypeScriptPreview = (input) => {
+  const inputPreview = input.inputSchema !== void 0 ? schemaToTypeScriptPreviewWithDefs(input.inputSchema, input.defs, input.options) : null;
+  const outputPreview = input.outputSchema !== void 0 ? schemaToTypeScriptPreviewWithDefs(input.outputSchema, input.defs, input.options) : null;
+  const mergedDefinitions = {
+    ...inputPreview?.definitions,
+    ...outputPreview?.definitions
+  };
+  return {
+    ...inputPreview ? { inputTypeScript: inputPreview.type } : {},
+    ...outputPreview ? { outputTypeScript: outputPreview.type } : {},
+    ...Object.keys(mergedDefinitions).length > 0 ? { typeScriptDefinitions: mergedDefinitions } : {}
+  };
+};
+
+// src/executor.ts
+import { Context, Deferred, Effect as Effect10, Option, Result as Result2, Schema as Schema11, Semaphore } from "effect";
+import { generateKeyBetween } from "fractional-indexing";
+import {
+  StorageError as StorageError3,
+  typedAdapter
+} from "@executor-js/storage-core";
+
+// src/scoped-adapter.ts
+import { Effect as Effect9 } from "effect";
+import {
+  StorageError as StorageError2
+} from "@executor-js/storage-core";
+var SCOPE_FIELD = "scope_id";
+var collectScopedModels = (schema) => {
+  const out = /* @__PURE__ */ new Set();
+  for (const [model, def] of Object.entries(schema)) {
+    if (def.fields[SCOPE_FIELD]) out.add(model);
+  }
+  return out;
+};
+var withScopeRead = (where, ctx) => {
+  const base = (where ?? []).filter((w) => w.field !== SCOPE_FIELD);
+  const callerScope = (where ?? []).find((w) => w.field === SCOPE_FIELD);
+  if (callerScope && typeof callerScope.value === "string" && ctx.scopes.includes(callerScope.value)) {
+    return [...base, { field: SCOPE_FIELD, value: callerScope.value }];
+  }
+  const scope = ctx.scopes.length === 1 ? { field: SCOPE_FIELD, value: ctx.scopes[0] } : { field: SCOPE_FIELD, value: [...ctx.scopes], operator: "in" };
+  return [...base, scope];
+};
+var assertScopedWrite = (model, data, ctx) => {
+  const value = data[SCOPE_FIELD];
+  if (typeof value !== "string" || value.length === 0) {
+    return Effect9.fail(
+      new StorageError2({
+        message: `Write to scoped table "${model}" missing required \`scope_id\`. Callers must name the target scope explicitly.`,
+        cause: void 0
+      })
+    );
+  }
+  if (!ctx.scopes.includes(value)) {
+    return Effect9.fail(
+      new StorageError2({
+        message: `Write to scoped table "${model}" targets scope "${value}" which is not in the executor's scope stack [${ctx.scopes.join(", ")}].`,
+        cause: void 0
+      })
+    );
+  }
+  return Effect9.void;
+};
+var wrapTxMethods = (inner, ctx, scopedModels) => {
+  const isScoped = (model) => scopedModels.has(model);
+  return {
+    id: inner.id,
+    create: (data) => isScoped(data.model) ? Effect9.flatMap(
+      assertScopedWrite(
+        data.model,
+        data.data,
+        ctx
+      ),
+      () => inner.create(data)
+    ) : inner.create(data),
+    createMany: (data) => isScoped(data.model) ? Effect9.flatMap(
+      Effect9.all(
+        data.data.map(
+          (row) => assertScopedWrite(
+            data.model,
+            row,
+            ctx
+          )
+        )
+      ),
+      () => inner.createMany(data)
+    ) : inner.createMany(data),
+    findOne: (data) => isScoped(data.model) ? inner.findOne({ ...data, where: withScopeRead(data.where, ctx) }) : inner.findOne(data),
+    findMany: (data) => isScoped(data.model) ? inner.findMany({ ...data, where: withScopeRead(data.where, ctx) }) : inner.findMany(data),
+    count: (data) => isScoped(data.model) ? inner.count({ ...data, where: withScopeRead(data.where, ctx) }) : inner.count(data),
+    update: (data) => isScoped(data.model) ? Effect9.flatMap(
+      // If the caller sets `scope_id` in the update payload, it
+      // must be one of the allowed scopes. If they don't, we leave
+      // the row's existing scope_id in place — updates are scoped
+      // by the where filter's IN clause, so you can only mutate
+      // rows you can read. That's sufficient for isolation; we
+      // don't need to force-stamp on update.
+      data.update[SCOPE_FIELD] !== void 0 ? assertScopedWrite(
+        data.model,
+        data.update,
+        ctx
+      ) : Effect9.void,
+      () => inner.update({
+        ...data,
+        where: withScopeRead(data.where, ctx)
+      })
+    ) : inner.update(data),
+    updateMany: (data) => isScoped(data.model) ? Effect9.flatMap(
+      data.update[SCOPE_FIELD] !== void 0 ? assertScopedWrite(
+        data.model,
+        data.update,
+        ctx
+      ) : Effect9.void,
+      () => inner.updateMany({
+        ...data,
+        where: withScopeRead(data.where, ctx)
+      })
+    ) : inner.updateMany(data),
+    delete: (data) => isScoped(data.model) ? inner.delete({ ...data, where: withScopeRead(data.where, ctx) }) : inner.delete(data),
+    deleteMany: (data) => isScoped(data.model) ? inner.deleteMany({ ...data, where: withScopeRead(data.where, ctx) }) : inner.deleteMany(data)
+  };
+};
+var scopeAdapter = (inner, ctx, schema) => {
+  const scopedModels = collectScopedModels(schema);
+  const tx = wrapTxMethods(inner, ctx, scopedModels);
+  return {
+    ...tx,
+    transaction: (callback) => inner.transaction((rawTrx) => {
+      const scopedTrx = wrapTxMethods(
+        rawTrx,
+        ctx,
+        scopedModels
+      );
+      return callback(scopedTrx);
+    }),
+    createSchema: inner.createSchema,
+    options: inner.options
+  };
+};
+
+// src/executor.ts
+var acceptAllHandler = () => Effect10.succeed(new ElicitationResponse({ action: "accept" }));
+var resolveElicitationHandler = (onElicitation) => onElicitation === "accept-all" ? acceptAllHandler : onElicitation;
+var collectSchemas = (plugins) => {
+  const merged = { ...coreSchema };
+  for (const plugin of plugins) {
+    if (!plugin.schema) continue;
+    for (const [modelKey, model] of Object.entries(plugin.schema)) {
+      if (merged[modelKey]) {
+        throw new Error(
+          `Duplicate model "${modelKey}" contributed by plugin "${plugin.id}" (reserved by core or another plugin)`
+        );
+      }
+      merged[modelKey] = model;
+    }
+  }
+  return merged;
+};
+var rowToSource = (row) => ({
+  id: row.id,
+  scopeId: row.scope_id,
+  kind: row.kind,
+  name: row.name,
+  url: row.url ?? void 0,
+  pluginId: row.plugin_id,
+  canRemove: Boolean(row.can_remove),
+  canRefresh: Boolean(row.can_refresh),
+  canEdit: Boolean(row.can_edit),
+  runtime: false
+});
+var staticDeclToSource = (decl, pluginId) => ({
+  id: decl.id,
+  scopeId: void 0,
+  kind: decl.kind,
+  name: decl.name,
+  url: decl.url,
+  pluginId,
+  canRemove: decl.canRemove ?? false,
+  canRefresh: decl.canRefresh ?? false,
+  canEdit: decl.canEdit ?? false,
+  runtime: true
+});
+var decodeJsonColumn = (value) => {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+};
+var rowToTool = (row, annotations) => ({
+  id: row.id,
+  sourceId: row.source_id,
+  pluginId: row.plugin_id,
+  name: row.name,
+  description: row.description,
+  inputSchema: decodeJsonColumn(row.input_schema),
+  outputSchema: decodeJsonColumn(row.output_schema),
+  annotations
+});
+var staticDeclToTool = (source, tool, pluginId) => ({
+  id: `${source.id}.${tool.name}`,
+  sourceId: source.id,
+  pluginId,
+  name: tool.name,
+  description: tool.description,
+  inputSchema: tool.inputSchema,
+  outputSchema: tool.outputSchema,
+  annotations: tool.annotations
+});
+var writeSourceInput = (core, pluginId, input) => Effect10.gen(function* () {
+  yield* deleteSourceById(core, input.id, input.scope);
+  const now = /* @__PURE__ */ new Date();
+  yield* core.create({
+    model: "source",
+    data: {
+      id: input.id,
+      scope_id: input.scope,
+      plugin_id: pluginId,
+      kind: input.kind,
+      name: input.name,
+      url: input.url ?? void 0,
+      can_remove: input.canRemove ?? true,
+      can_refresh: input.canRefresh ?? false,
+      can_edit: input.canEdit ?? false,
+      created_at: now,
+      updated_at: now
+    },
+    forceAllowId: true
+  });
+  if (input.tools.length > 0) {
+    yield* core.createMany({
+      model: "tool",
+      data: input.tools.map((tool) => ({
+        id: `${input.id}.${tool.name}`,
+        scope_id: input.scope,
+        source_id: input.id,
+        plugin_id: pluginId,
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.inputSchema ?? void 0,
+        output_schema: tool.outputSchema ?? void 0,
+        created_at: now,
+        updated_at: now
+      })),
+      forceAllowId: true
+    });
+  }
+});
+var deleteSourceById = (core, sourceId, scopeId) => Effect10.gen(function* () {
+  yield* core.deleteMany({
+    model: "tool",
+    where: [
+      { field: "source_id", value: sourceId },
+      { field: "scope_id", value: scopeId }
+    ]
+  });
+  yield* core.deleteMany({
+    model: "definition",
+    where: [
+      { field: "source_id", value: sourceId },
+      { field: "scope_id", value: scopeId }
+    ]
+  });
+  yield* core.delete({
+    model: "source",
+    where: [
+      { field: "id", value: sourceId },
+      { field: "scope_id", value: scopeId }
+    ]
+  });
+});
+var writeDefinitions = (core, pluginId, input) => Effect10.gen(function* () {
+  yield* core.deleteMany({
+    model: "definition",
+    where: [
+      { field: "source_id", value: input.sourceId },
+      { field: "scope_id", value: input.scope }
+    ]
+  });
+  const entries = Object.entries(input.definitions);
+  if (entries.length === 0) return;
+  const now = /* @__PURE__ */ new Date();
+  yield* core.createMany({
+    model: "definition",
+    data: entries.map(([name, schema]) => ({
+      id: `${input.sourceId}.${name}`,
+      scope_id: input.scope,
+      source_id: input.sourceId,
+      plugin_id: pluginId,
+      name,
+      schema,
+      created_at: now
+    })),
+    forceAllowId: true
+  });
+});
+var toolMatchesFilter = (tool, filter) => {
+  if (filter.sourceId && tool.sourceId !== filter.sourceId) return false;
+  if (filter.query) {
+    const q = filter.query.toLowerCase();
+    const hay = `${tool.name} ${tool.description}`.toLowerCase();
+    if (!hay.includes(q)) return false;
+  }
+  return true;
+};
+var activeAdapterRef = Context.Reference(
+  "executor/ActiveAdapter",
+  { defaultValue: () => null }
+);
+var buildAdapterRouter = (root) => {
+  const pick = (use) => Effect10.flatMap(
+    Effect10.service(activeAdapterRef),
+    (active) => use(active ?? root)
+  );
+  return {
+    id: root.id,
+    create: (data) => pick((a) => a.create(data)),
+    createMany: (data) => pick((a) => a.createMany(data)),
+    findOne: (data) => pick((a) => a.findOne(data)),
+    findMany: (data) => pick((a) => a.findMany(data)),
+    count: (data) => pick((a) => a.count(data)),
+    update: (data) => pick((a) => a.update(data)),
+    updateMany: (data) => pick((a) => a.updateMany(data)),
+    delete: (data) => pick((a) => a.delete(data)),
+    deleteMany: (data) => pick((a) => a.deleteMany(data)),
+    // transaction() always opens a real boundary on the ROOT adapter so the
+    // tx uses one real connection from the pool. If we're already inside a
+    // parent tx (FiberRef set), skip opening a nested sql.begin — that's
+    // the postgres.js + Hyperdrive deadlock path — and just run the
+    // callback with the existing tx handle. In both cases the callback
+    // sees a FiberRef-substituted adapter so further nested writes thread
+    // through.
+    transaction: (callback) => Effect10.flatMap(Effect10.service(activeAdapterRef), (active) => {
+      if (active) return callback(active);
+      return root.transaction(
+        (trx) => Effect10.provideService(callback(trx), activeAdapterRef, trx)
+      );
+    })
+  };
+};
+var createExecutor = (config) => Effect10.gen(function* () {
+  const defaultPlugins = () => {
+    const empty = [];
+    return empty;
+  };
+  const {
+    scopes,
+    adapter: rootAdapter,
+    blobs,
+    plugins = defaultPlugins()
+  } = config;
+  if (scopes.length === 0) {
+    return yield* Effect10.fail(
+      new Error("createExecutor requires a non-empty scopes array")
+    );
+  }
+  const schema = collectSchemas(plugins);
+  const scopeIds = scopes.map((s) => s.id);
+  const scopedRoot = scopeAdapter(
+    rootAdapter,
+    { scopes: scopeIds },
+    schema
+  );
+  const adapter = buildAdapterRouter(scopedRoot);
+  const core = typedAdapter(adapter);
+  const staticTools = /* @__PURE__ */ new Map();
+  const staticSources = /* @__PURE__ */ new Map();
+  const runtimes = /* @__PURE__ */ new Map();
+  const secretProviders = /* @__PURE__ */ new Map();
+  const connectionProviders = /* @__PURE__ */ new Map();
+  const connectionProviderAliases = /* @__PURE__ */ new Map([
+    ["mcp:oauth2", "oauth2"],
+    ["openapi:oauth2", "oauth2"],
+    ["google-discovery:google", "oauth2"],
+    ["google-discovery:oauth2", "oauth2"]
+  ]);
+  const resolveConnectionProvider = (key) => {
+    const direct = connectionProviders.get(key);
+    if (direct) return direct;
+    const canonical = connectionProviderAliases.get(key);
+    return canonical ? connectionProviders.get(canonical) : void 0;
+  };
+  const refreshInFlight = /* @__PURE__ */ new Map();
+  const refreshInFlightLock = Semaphore.makeUnsafe(1);
+  const extensions = {};
+  const scopePrecedence = /* @__PURE__ */ new Map();
+  scopeIds.forEach((s, i) => scopePrecedence.set(s, i));
+  const scopeRank = (row) => scopePrecedence.get(row.scope_id) ?? Infinity;
+  const findInnermost = (rows) => {
+    if (rows.length === 0) return null;
+    let winner;
+    let best = Infinity;
+    for (const row of rows) {
+      const rank = scopeRank(row);
+      if (rank < best) {
+        best = rank;
+        winner = row;
+      }
+    }
+    return winner ?? null;
+  };
+  const secretRowsForId = (id) => core.findMany({
+    model: "secret",
+    where: [{ field: "id", value: id }]
+  });
+  const resolveSecretValueFromRows = (id, rows) => Effect10.gen(function* () {
+    const ordered = [...rows].sort(
+      (a, b) => (scopePrecedence.get(a.scope_id) ?? Infinity) - (scopePrecedence.get(b.scope_id) ?? Infinity)
+    );
+    for (const row of ordered) {
+      const provider = secretProviders.get(row.provider);
+      if (!provider) continue;
+      const value = yield* provider.get(id, row.scope_id);
+      if (value !== null) return value;
+    }
+    const fallbackScope = scopeIds[0];
+    const candidates = [...secretProviders.values()].filter(
+      (p) => p.list
+    );
+    const values = yield* Effect10.all(
+      candidates.map(
+        (p) => p.get(id, fallbackScope).pipe(Effect10.catch(() => Effect10.succeed(null)))
+      ),
+      { concurrency: "unbounded" }
+    );
+    for (const value of values) if (value !== null) return value;
+    return null;
+  });
+  const secretsGet = (id) => Effect10.gen(function* () {
+    const rows = yield* secretRowsForId(id);
+    const owned = rows.find((row) => row.owned_by_connection_id);
+    if (owned) {
+      return yield* Effect10.fail(
+        new SecretOwnedByConnectionError({
+          secretId: SecretId.make(id),
+          connectionId: ConnectionId.make(
+            owned.owned_by_connection_id
+          )
+        })
+      );
+    }
+    return yield* resolveSecretValueFromRows(id, rows);
+  });
+  const connectionSecretGet = (id) => Effect10.gen(function* () {
+    const rows = yield* secretRowsForId(id);
+    return yield* resolveSecretValueFromRows(id, rows);
+  });
+  const secretRouteHasBackingValue = (row) => {
+    const provider = secretProviders.get(row.provider);
+    if (!provider?.has) return Effect10.succeed(true);
+    return provider.has(row.id, row.scope_id).pipe(Effect10.catch(() => Effect10.succeed(false)));
+  };
+  const secretsSet = (input) => Effect10.gen(function* () {
+    if (!scopeIds.includes(input.scope)) {
+      return yield* Effect10.fail(
+        new StorageError3({
+          message: `secrets.set targets scope "${input.scope}" which is not in the executor's scope stack [${scopeIds.join(", ")}].`,
+          cause: void 0
+        })
+      );
+    }
+    let target;
+    if (input.provider) {
+      target = secretProviders.get(input.provider);
+      if (!target) {
+        return yield* Effect10.fail(
+          new StorageError3({
+            message: `Unknown secret provider: ${input.provider}`,
+            cause: void 0
+          })
+        );
+      }
+    } else {
+      for (const provider of secretProviders.values()) {
+        if (provider.writable && provider.set) {
+          target = provider;
+          break;
+        }
+      }
+      if (!target) {
+        return yield* Effect10.fail(
+          new StorageError3({
+            message: "No writable secret providers registered",
+            cause: void 0
+          })
+        );
+      }
+    }
+    if (!target.writable || !target.set) {
+      return yield* Effect10.fail(
+        new StorageError3({
+          message: `Secret provider "${target.key}" is read-only`,
+          cause: void 0
+        })
+      );
+    }
+    yield* target.set(input.id, input.value, input.scope);
+    const now = /* @__PURE__ */ new Date();
+    yield* core.delete({
+      model: "secret",
+      where: [
+        { field: "id", value: input.id },
+        { field: "scope_id", value: input.scope }
+      ]
+    });
+    yield* core.create({
+      model: "secret",
+      data: {
+        id: input.id,
+        scope_id: input.scope,
+        name: input.name,
+        provider: target.key,
+        created_at: now
+      },
+      forceAllowId: true
+    });
+    return new SecretRef({
+      id: input.id,
+      scopeId: input.scope,
+      name: input.name,
+      provider: target.key,
+      createdAt: now
+    });
+  });
+  const secretsRemove = (id) => Effect10.gen(function* () {
+    const rows = yield* core.findMany({
+      model: "secret",
+      where: [{ field: "id", value: id }]
+    });
+    const target = findInnermost(rows);
+    if (target && target.owned_by_connection_id) {
+      return yield* Effect10.fail(
+        new SecretOwnedByConnectionError({
+          secretId: SecretId.make(id),
+          connectionId: ConnectionId.make(
+            target.owned_by_connection_id
+          )
+        })
+      );
+    }
+    const targetScope = target?.scope_id ?? scopeIds[0];
+    const deleters = [...secretProviders.values()].filter(
+      (p) => !!(p.writable && p.delete)
+    );
+    yield* Effect10.all(
+      deleters.map((p) => p.delete(id, targetScope)),
+      { concurrency: "unbounded" }
+    );
+    if (target) {
+      yield* core.delete({
+        model: "secret",
+        where: [
+          { field: "id", value: id },
+          { field: "scope_id", value: targetScope }
+        ]
+      });
+    }
+  });
+  const secretsList = () => Effect10.gen(function* () {
+    const byId = /* @__PURE__ */ new Map();
+    const allRows = yield* core.findMany({ model: "secret" });
+    const connectionOwnedIds = new Set(
+      allRows.filter((r) => r.owned_by_connection_id).map((r) => r.id)
+    );
+    const rows = allRows.filter((r) => !r.owned_by_connection_id);
+    const precedence = /* @__PURE__ */ new Map();
+    scopeIds.forEach((id, index) => precedence.set(id, index));
+    const pick = (row) => {
+      const existing = byId.get(row.id);
+      const incomingScope = row.scope_id;
+      const incomingRank = precedence.get(incomingScope) ?? Number.MAX_SAFE_INTEGER;
+      if (existing) {
+        const existingRank = precedence.get(existing.scopeId) ?? Number.MAX_SAFE_INTEGER;
+        if (existingRank <= incomingRank) return;
+      }
+      byId.set(
+        row.id,
+        new SecretRef({
+          id: SecretId.make(row.id),
+          scopeId: ScopeId.make(incomingScope),
+          name: row.name,
+          provider: row.provider,
+          createdAt: row.created_at instanceof Date ? row.created_at : new Date(row.created_at)
+        })
+      );
+    };
+    for (const row of rows) {
+      const hasBackingValue = yield* secretRouteHasBackingValue(row);
+      if (hasBackingValue) pick(row);
+    }
+    const attribution = scopes[0].id;
+    const listers = [...secretProviders.entries()].filter(
+      ([, p]) => p.list
+    );
+    const lists = yield* Effect10.all(
+      listers.map(
+        ([key, p]) => p.list().pipe(
+          Effect10.catch(() => Effect10.succeed([])),
+          Effect10.map((entries) => ({ key, entries }))
+        )
+      ),
+      { concurrency: "unbounded" }
+    );
+    for (const { key, entries } of lists) {
+      for (const entry of entries) {
+        if (byId.has(entry.id)) continue;
+        if (connectionOwnedIds.has(entry.id)) continue;
+        byId.set(
+          entry.id,
+          new SecretRef({
+            id: SecretId.make(entry.id),
+            scopeId: attribution,
+            name: entry.name,
+            provider: key,
+            createdAt: /* @__PURE__ */ new Date()
+          })
+        );
+      }
+    }
+    return Array.from(byId.values());
+  });
+  const secretsListForCtx = () => Effect10.gen(function* () {
+    const list = yield* secretsList();
+    return list.map((ref) => ({
+      id: String(ref.id),
+      name: ref.name,
+      provider: ref.provider
+    }));
+  });
+  const CONNECTION_REFRESH_SKEW_MS = 6e4;
+  const decodeProviderState2 = Schema11.decodeUnknownOption(
+    ConnectionProviderState
+  );
+  const rowToConnection = (row) => new ConnectionRef({
+    id: ConnectionId.make(row.id),
+    scopeId: ScopeId.make(row.scope_id),
+    provider: row.provider,
+    identityLabel: row.identity_label ?? null,
+    accessTokenSecretId: SecretId.make(row.access_token_secret_id),
+    refreshTokenSecretId: row.refresh_token_secret_id != null ? SecretId.make(row.refresh_token_secret_id) : null,
+    expiresAt: row.expires_at != null ? Number(row.expires_at) : null,
+    oauthScope: row.scope ?? null,
+    providerState: Option.getOrNull(
+      decodeProviderState2(decodeJsonColumn(row.provider_state))
+    ),
+    createdAt: row.created_at instanceof Date ? row.created_at : new Date(row.created_at),
+    updatedAt: row.updated_at instanceof Date ? row.updated_at : new Date(row.updated_at)
+  });
+  const findInnermostConnectionRow = (id) => Effect10.gen(function* () {
+    const rows = yield* core.findMany({
+      model: "connection",
+      where: [{ field: "id", value: id }]
+    });
+    return findInnermost(rows);
+  });
+  const connectionsGet = (id) => Effect10.gen(function* () {
+    const row = yield* findInnermostConnectionRow(id);
+    return row ? rowToConnection(row) : null;
+  });
+  const connectionsList = () => Effect10.gen(function* () {
+    const rows = yield* core.findMany({ model: "connection" });
+    const byId = /* @__PURE__ */ new Map();
+    const byIdRank = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const rank = scopeRank(row);
+      const existing = byIdRank.get(row.id);
+      if (existing === void 0 || rank < existing) {
+        byId.set(row.id, row);
+        byIdRank.set(row.id, rank);
+      }
+    }
+    return [...byId.values()].map(rowToConnection);
+  });
+  const writeOwnedSecret = (params) => Effect10.gen(function* () {
+    const target = secretProviders.get(params.provider);
+    if (!target) {
+      return yield* Effect10.fail(
+        new StorageError3({
+          message: `Unknown secret provider: ${params.provider}`,
+          cause: void 0
+        })
+      );
+    }
+    if (!target.writable || !target.set) {
+      return yield* Effect10.fail(
+        new StorageError3({
+          message: `Secret provider "${target.key}" is read-only`,
+          cause: void 0
+        })
+      );
+    }
+    yield* target.set(params.id, params.value, params.scope);
+    const now = /* @__PURE__ */ new Date();
+    yield* core.delete({
+      model: "secret",
+      where: [
+        { field: "id", value: params.id },
+        { field: "scope_id", value: params.scope }
+      ]
+    });
+    yield* core.create({
+      model: "secret",
+      data: {
+        id: params.id,
+        scope_id: params.scope,
+        name: params.name,
+        provider: target.key,
+        owned_by_connection_id: params.ownedByConnectionId,
+        created_at: now
+      },
+      forceAllowId: true
+    });
+  });
+  const pickWritableProvider = (requested) => Effect10.gen(function* () {
+    if (requested) {
+      const p = secretProviders.get(requested);
+      if (!p) {
+        return yield* Effect10.fail(
+          new StorageError3({
+            message: `Unknown secret provider: ${requested}`,
+            cause: void 0
+          })
+        );
+      }
+      return p;
+    }
+    for (const p of secretProviders.values()) {
+      if (p.writable && p.set) return p;
+    }
+    return yield* Effect10.fail(
+      new StorageError3({
+        message: "No writable secret providers registered",
+        cause: void 0
+      })
+    );
+  });
+  const connectionsCreate = (input) => Effect10.gen(function* () {
+    if (!scopeIds.includes(input.scope)) {
+      return yield* Effect10.fail(
+        new StorageError3({
+          message: `connections.create targets scope "${input.scope}" which is not in the executor's scope stack [${scopeIds.join(", ")}].`,
+          cause: void 0
+        })
+      );
+    }
+    if (!resolveConnectionProvider(input.provider)) {
+      return yield* Effect10.fail(
+        new ConnectionProviderNotRegisteredError({
+          provider: input.provider,
+          connectionId: input.id
+        })
+      );
+    }
+    const writable = yield* pickWritableProvider();
+    const now = /* @__PURE__ */ new Date();
+    return yield* adapter.transaction(
+      () => Effect10.gen(function* () {
+        yield* core.delete({
+          model: "connection",
+          where: [
+            { field: "id", value: input.id },
+            { field: "scope_id", value: input.scope }
+          ]
+        });
+        yield* writeOwnedSecret({
+          id: input.accessToken.secretId,
+          scope: input.scope,
+          name: input.accessToken.name,
+          value: input.accessToken.value,
+          provider: writable.key,
+          ownedByConnectionId: input.id
+        });
+        if (input.refreshToken) {
+          yield* writeOwnedSecret({
+            id: input.refreshToken.secretId,
+            scope: input.scope,
+            name: input.refreshToken.name,
+            value: input.refreshToken.value,
+            provider: writable.key,
+            ownedByConnectionId: input.id
+          });
+        }
+        yield* core.create({
+          model: "connection",
+          data: {
+            id: input.id,
+            scope_id: input.scope,
+            provider: input.provider,
+            identity_label: input.identityLabel ?? void 0,
+            access_token_secret_id: input.accessToken.secretId,
+            refresh_token_secret_id: input.refreshToken?.secretId ?? void 0,
+            expires_at: input.expiresAt ?? void 0,
+            scope: input.oauthScope ?? void 0,
+            provider_state: input.providerState ?? void 0,
+            created_at: now,
+            updated_at: now
+          },
+          forceAllowId: true
+        });
+        return new ConnectionRef({
+          id: input.id,
+          scopeId: input.scope,
+          provider: input.provider,
+          identityLabel: input.identityLabel,
+          accessTokenSecretId: input.accessToken.secretId,
+          refreshTokenSecretId: input.refreshToken?.secretId ?? null,
+          expiresAt: input.expiresAt,
+          oauthScope: input.oauthScope,
+          providerState: input.providerState,
+          createdAt: now,
+          updatedAt: now
+        });
+      })
+    );
+  });
+  const connectionsUpdateTokens = (input) => Effect10.gen(function* () {
+    const row = yield* findInnermostConnectionRow(input.id);
+    if (!row) {
+      return yield* Effect10.fail(
+        new ConnectionNotFoundError({ connectionId: input.id })
+      );
+    }
+    const writable = yield* pickWritableProvider();
+    const accessName = `Connection ${input.id} access token`;
+    const refreshName = `Connection ${input.id} refresh token`;
+    return yield* adapter.transaction(
+      () => Effect10.gen(function* () {
+        yield* writeOwnedSecret({
+          id: row.access_token_secret_id,
+          scope: row.scope_id,
+          name: accessName,
+          value: input.accessToken,
+          provider: writable.key,
+          ownedByConnectionId: row.id
+        });
+        const rotatedRefresh = input.refreshToken ?? void 0;
+        if (rotatedRefresh && row.refresh_token_secret_id) {
+          yield* writeOwnedSecret({
+            id: row.refresh_token_secret_id,
+            scope: row.scope_id,
+            name: refreshName,
+            value: rotatedRefresh,
+            provider: writable.key,
+            ownedByConnectionId: row.id
+          });
+        }
+        const now = /* @__PURE__ */ new Date();
+        const patch = { updated_at: now };
+        if (input.expiresAt !== void 0)
+          patch.expires_at = input.expiresAt ?? void 0;
+        if (input.oauthScope !== void 0)
+          patch.scope = input.oauthScope ?? void 0;
+        if (input.providerState !== void 0)
+          patch.provider_state = input.providerState ?? void 0;
+        if (input.identityLabel !== void 0)
+          patch.identity_label = input.identityLabel ?? void 0;
+        yield* core.update({
+          model: "connection",
+          where: [
+            { field: "id", value: row.id },
+            { field: "scope_id", value: row.scope_id }
+          ],
+          update: patch
+        });
+        const updated = yield* findInnermostConnectionRow(
+          row.id
+        );
+        if (!updated) {
+          return yield* Effect10.fail(
+            new ConnectionNotFoundError({ connectionId: input.id })
+          );
+        }
+        return rowToConnection(updated);
+      })
+    );
+  });
+  const connectionsSetIdentityLabel = (id, label) => Effect10.gen(function* () {
+    const row = yield* findInnermostConnectionRow(id);
+    if (!row) {
+      return yield* Effect10.fail(
+        new ConnectionNotFoundError({
+          connectionId: ConnectionId.make(id)
+        })
+      );
+    }
+    yield* core.update({
+      model: "connection",
+      where: [
+        { field: "id", value: id },
+        { field: "scope_id", value: row.scope_id }
+      ],
+      update: {
+        identity_label: label ?? void 0,
+        updated_at: /* @__PURE__ */ new Date()
+      }
+    });
+  });
+  const connectionsRemove = (id) => Effect10.gen(function* () {
+    const row = yield* findInnermostConnectionRow(id);
+    if (!row) return;
+    const scope = row.scope_id;
+    yield* adapter.transaction(
+      () => Effect10.gen(function* () {
+        const owned = yield* core.findMany({
+          model: "secret",
+          where: [
+            { field: "owned_by_connection_id", value: id },
+            { field: "scope_id", value: scope }
+          ]
+        });
+        const deleters = [...secretProviders.values()].filter(
+          (p) => !!(p.writable && p.delete)
+        );
+        for (const secret of owned) {
+          yield* Effect10.all(
+            deleters.map(
+              (p) => p.delete(secret.id, scope).pipe(
+                Effect10.catchCause(
+                  (cause) => Effect10.logWarning(
+                    `Failed to delete connection-owned secret from provider ${p.key}`,
+                    cause
+                  ).pipe(Effect10.as(false))
+                )
+              )
+            ),
+            { concurrency: "unbounded" }
+          );
+        }
+        yield* core.deleteMany({
+          model: "secret",
+          where: [
+            { field: "owned_by_connection_id", value: id },
+            { field: "scope_id", value: scope }
+          ]
+        });
+        yield* core.delete({
+          model: "connection",
+          where: [
+            { field: "id", value: id },
+            { field: "scope_id", value: scope }
+          ]
+        });
+      })
+    );
+  });
+  const performRefresh = (ref) => Effect10.gen(function* () {
+    const provider = resolveConnectionProvider(ref.provider);
+    if (!provider) {
+      return yield* Effect10.fail(
+        new ConnectionProviderNotRegisteredError({
+          provider: ref.provider,
+          connectionId: ref.id
+        })
+      );
+    }
+    if (!provider.refresh) {
+      return yield* Effect10.fail(
+        new ConnectionRefreshNotSupportedError({
+          connectionId: ref.id,
+          provider: ref.provider
+        })
+      );
+    }
+    const refreshTokenValue = ref.refreshTokenSecretId ? yield* connectionSecretGet(ref.refreshTokenSecretId) : null;
+    const rawResult = yield* Effect10.result(
+      provider.refresh({
+        connectionId: ref.id,
+        scopeId: ref.scopeId,
+        identityLabel: ref.identityLabel,
+        refreshToken: refreshTokenValue,
+        providerState: ref.providerState,
+        oauthScope: ref.oauthScope
+      })
+    );
+    if (Result2.isFailure(rawResult)) {
+      const err = rawResult.failure;
+      if (err.reauthRequired) {
+        return yield* Effect10.fail(
+          new ConnectionReauthRequiredError({
+            connectionId: err.connectionId,
+            provider: ref.provider,
+            message: err.message
+          })
+        );
+      }
+      return yield* Effect10.fail(err);
+    }
+    const result = rawResult.success;
+    yield* connectionsUpdateTokens({
+      id: ref.id,
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresAt: result.expiresAt,
+      oauthScope: result.oauthScope,
+      providerState: result.providerState
+    });
+    return result.accessToken;
+  });
+  const connectionsAccessToken = (id) => Effect10.gen(function* () {
+    const row = yield* findInnermostConnectionRow(id);
+    if (!row) {
+      return yield* Effect10.fail(
+        new ConnectionNotFoundError({
+          connectionId: ConnectionId.make(id)
+        })
+      );
+    }
+    const ref = rowToConnection(row);
+    const now = Date.now();
+    const needsRefresh = ref.expiresAt !== null && ref.expiresAt - CONNECTION_REFRESH_SKEW_MS <= now;
+    if (!needsRefresh) {
+      const current = yield* connectionSecretGet(
+        ref.accessTokenSecretId
+      );
+      if (current !== null) return current;
+    }
+    const action = yield* refreshInFlightLock.withPermits(1)(
+      Effect10.gen(function* () {
+        const existing = refreshInFlight.get(id);
+        if (existing) {
+          return {
+            kind: "await",
+            deferred: existing
+          };
+        }
+        const deferred = yield* Deferred.make();
+        refreshInFlight.set(id, deferred);
+        return { kind: "lead", deferred };
+      })
+    );
+    if (action.kind === "await") {
+      return yield* Deferred.await(action.deferred);
+    }
+    return yield* performRefresh(ref).pipe(
+      Effect10.onExit(
+        (exit) => refreshInFlightLock.withPermits(1)(
+          Effect10.gen(function* () {
+            yield* Deferred.done(action.deferred, exit);
+            refreshInFlight.delete(id);
+          })
+        )
+      )
+    );
+  });
+  const connectionsListForCtx = () => connectionsList();
+  const oauthBundle = makeOAuth2Service({
+    adapter: core,
+    rawAdapter: adapter,
+    secretsGet: (id) => secretsGet(id).pipe(
+      Effect10.catchTag(
+        "SecretOwnedByConnectionError",
+        () => Effect10.succeed(null)
+      )
+    ),
+    secretsSet: (input) => secretsSet(input),
+    connectionsCreate: (input) => connectionsCreate(input)
+  });
+  connectionProviders.set(
+    oauthBundle.connectionProvider.key,
+    oauthBundle.connectionProvider
+  );
+  for (const plugin of plugins) {
+    if (runtimes.has(plugin.id)) {
+      return yield* Effect10.fail(
+        new Error(`Duplicate plugin id: ${plugin.id}`)
+      );
+    }
+    const storageDeps = {
+      scopes,
+      adapter: typedAdapter(adapter),
+      // Blob keys are namespaced by `<scope>/<plugin>` so two tenants
+      // sharing a backing BlobStore can't collide or leak on the
+      // same `(plugin, key)` pair. The store's `get`/`has` walk the
+      // scope stack (innermost first); `put`/`delete` require the
+      // plugin to name a target scope explicitly.
+      blobs: pluginBlobStore(blobs, scopeIds, plugin.id)
+    };
+    const storage = plugin.storage(storageDeps);
+    const ctx = {
+      scopes,
+      storage,
+      core: {
+        sources: {
+          register: (input) => Effect10.gen(function* () {
+            if (staticSources.has(input.id)) {
+              return yield* Effect10.fail(
+                new StorageError3({
+                  message: `Source id "${input.id}" collides with a static source`,
+                  cause: void 0
+                })
+              );
+            }
+            for (const tool of input.tools) {
+              const fqid = `${input.id}.${tool.name}`;
+              if (staticTools.has(fqid)) {
+                return yield* Effect10.fail(
+                  new StorageError3({
+                    message: `Tool id "${fqid}" collides with a static tool`,
+                    cause: void 0
+                  })
+                );
+              }
+            }
+            yield* adapter.transaction(
+              () => writeSourceInput(core, plugin.id, input)
+            );
+          }),
+          unregister: (sourceId) => (
+            // `unregister` is scoped to a specific source row — look up
+            // its scope before deleting so the tool/definition sweep
+            // only touches rows at that scope. Walk the full stack and
+            // pick the innermost-scope shadow so an inner-scope caller
+            // can't accidentally (via non-deterministic findOne
+            // iteration order) unregister the outer-scope source and
+            // wipe a bystander's data at the same time.
+            adapter.transaction(
+              () => Effect10.gen(function* () {
+                const rows = yield* core.findMany({
+                  model: "source",
+                  where: [{ field: "id", value: sourceId }]
+                });
+                const row = findInnermost(rows);
+                if (!row) return;
+                yield* deleteSourceById(
+                  core,
+                  sourceId,
+                  row.scope_id
+                );
+              })
+            )
+          ),
+          update: (input) => core.update({
+            model: "source",
+            where: [
+              { field: "id", value: input.id },
+              { field: "scope_id", value: input.scope }
+            ],
+            update: {
+              ...input.name !== void 0 ? { name: input.name } : {},
+              ...input.url !== void 0 ? { url: input.url ?? void 0 } : {},
+              updated_at: /* @__PURE__ */ new Date()
+            }
+          }).pipe(Effect10.asVoid)
+        },
+        definitions: {
+          register: (input) => adapter.transaction(
+            () => writeDefinitions(core, plugin.id, input)
+          )
+        }
+      },
+      secrets: {
+        get: (id) => secretsGet(id),
+        list: () => secretsListForCtx(),
+        set: (input) => secretsSet(input),
+        remove: (id) => secretsRemove(id)
+      },
+      connections: {
+        get: (id) => connectionsGet(id),
+        list: () => connectionsListForCtx(),
+        create: (input) => connectionsCreate(input),
+        updateTokens: (input) => connectionsUpdateTokens(input),
+        setIdentityLabel: (id, label) => connectionsSetIdentityLabel(id, label),
+        accessToken: (id) => connectionsAccessToken(id),
+        remove: (id) => connectionsRemove(id)
+      },
+      oauth: oauthBundle.service,
+      // Open one real tx boundary and route every nested write inside
+      // `effect` through that same handle via the activeAdapterRef —
+      // see buildAdapterRouter above. Caller-typed errors (`E`)
+      // propagate unchanged; storage failures also stay typed
+      // (`StorageFailure`) so the HTTP edge wrapper can translate them.
+      transaction: (effect) => adapter.transaction(() => effect)
+    };
+    const extension = plugin.extension ? plugin.extension(ctx) : {};
+    if (plugin.extension) {
+      extensions[plugin.id] = extension;
+    }
+    const decls = plugin.staticSources ? plugin.staticSources(extension) : [];
+    for (const source of decls) {
+      if (staticSources.has(source.id)) {
+        return yield* Effect10.fail(
+          new Error(
+            `Duplicate static source id: ${source.id} (plugin ${plugin.id})`
+          )
+        );
+      }
+      staticSources.set(source.id, { source, pluginId: plugin.id });
+      for (const tool of source.tools) {
+        const fqid = `${source.id}.${tool.name}`;
+        if (staticTools.has(fqid)) {
+          return yield* Effect10.fail(
+            new Error(
+              `Duplicate static tool id: ${fqid} (plugin ${plugin.id})`
+            )
+          );
+        }
+        staticTools.set(fqid, {
+          source,
+          tool,
+          pluginId: plugin.id,
+          ctx
+        });
+      }
+    }
+    runtimes.set(plugin.id, { plugin, storage, ctx });
+    if (plugin.secretProviders) {
+      const raw = typeof plugin.secretProviders === "function" ? plugin.secretProviders(ctx) : plugin.secretProviders;
+      const providers = Effect10.isEffect(raw) ? yield* raw : raw;
+      for (const provider of providers) {
+        if (secretProviders.has(provider.key)) {
+          return yield* Effect10.fail(
+            new Error(
+              `Duplicate secret provider key: ${provider.key} (from plugin ${plugin.id})`
+            )
+          );
+        }
+        secretProviders.set(provider.key, provider);
+      }
+    }
+    if (plugin.connectionProviders) {
+      const raw = typeof plugin.connectionProviders === "function" ? plugin.connectionProviders(ctx) : plugin.connectionProviders;
+      const providers = Effect10.isEffect(raw) ? yield* raw : raw;
+      for (const provider of providers) {
+        if (connectionProviders.has(provider.key)) {
+          return yield* Effect10.fail(
+            new Error(
+              `Duplicate connection provider key: ${provider.key} (from plugin ${plugin.id})`
+            )
+          );
+        }
+        connectionProviders.set(provider.key, provider);
+      }
+    }
+  }
+  const listSources = () => Effect10.gen(function* () {
+    const dynamic = yield* core.findMany({ model: "source" });
+    const byId = /* @__PURE__ */ new Map();
+    const byIdRank = /* @__PURE__ */ new Map();
+    for (const row of dynamic) {
+      const rank = scopeRank(row);
+      const existing = byIdRank.get(row.id);
+      if (existing === void 0 || rank < existing) {
+        byId.set(row.id, row);
+        byIdRank.set(row.id, rank);
+      }
+    }
+    const dynamicDeduped = [...byId.values()];
+    const staticList = [];
+    for (const { source, pluginId } of staticSources.values()) {
+      staticList.push(staticDeclToSource(source, pluginId));
+    }
+    const merged = [...staticList, ...dynamicDeduped.map(rowToSource)];
+    yield* Effect10.annotateCurrentSpan({
+      "executor.sources.static_count": staticList.length,
+      "executor.sources.dynamic_count": dynamicDeduped.length
+    });
+    return merged;
+  }).pipe(Effect10.withSpan("executor.sources.list"));
+  const resolveAnnotationsFor = (rows) => Effect10.gen(function* () {
+    const result = /* @__PURE__ */ new Map();
+    if (rows.length === 0) return result;
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = `${row.plugin_id}\0${row.source_id}`;
+      const bucket = groups.get(key);
+      if (bucket) bucket.push(row);
+      else groups.set(key, [row]);
+    }
+    const maps = yield* Effect10.forEach(
+      [...groups],
+      ([key, groupRows]) => Effect10.gen(function* () {
+        const [pluginId, sourceId] = key.split("\0");
+        const runtime = runtimes.get(pluginId);
+        if (!runtime?.plugin.resolveAnnotations) return void 0;
+        return yield* runtime.plugin.resolveAnnotations({
+          ctx: runtime.ctx,
+          sourceId,
+          toolRows: groupRows
+        });
+      }),
+      { concurrency: "unbounded" }
+    );
+    for (const map of maps) {
+      if (!map) continue;
+      for (const [toolId, annotations] of Object.entries(map)) {
+        result.set(toolId, annotations);
+      }
+    }
+    return result;
+  });
+  const listTools = (filter) => Effect10.gen(function* () {
+    const dynamic = yield* core.findMany({
+      model: "tool",
+      where: filter?.sourceId ? [{ field: "source_id", value: filter.sourceId }] : void 0
+    });
+    const byId = /* @__PURE__ */ new Map();
+    const byIdRank = /* @__PURE__ */ new Map();
+    for (const row of dynamic) {
+      const rank = scopeRank(row);
+      const existing = byIdRank.get(row.id);
+      if (existing === void 0 || rank < existing) {
+        byId.set(row.id, row);
+        byIdRank.set(row.id, rank);
+      }
+    }
+    const dynamicDeduped = [...byId.values()];
+    const annotations = filter?.includeAnnotations === false ? /* @__PURE__ */ new Map() : yield* resolveAnnotationsFor(dynamicDeduped).pipe(
+      Effect10.withSpan("executor.tools.list.annotations")
+    );
+    const out = [];
+    for (const entry of staticTools.values()) {
+      out.push(staticDeclToTool(entry.source, entry.tool, entry.pluginId));
+    }
+    for (const row of dynamicDeduped) {
+      out.push(rowToTool(row, annotations.get(row.id)));
+    }
+    const filtered = filter ? out.filter((t) => toolMatchesFilter(t, filter)) : out;
+    let result = filtered;
+    let blockedCount = 0;
+    if (filter?.includeBlocked !== true) {
+      const policies = yield* loadAllPolicies();
+      if (policies.length > 0) {
+        const kept = [];
+        for (const tool of filtered) {
+          const match = resolveToolPolicy(tool.id, policies, scopeRank);
+          if (match?.action === "block") {
+            blockedCount++;
+            continue;
+          }
+          kept.push(tool);
+        }
+        result = kept;
+      }
+    }
+    yield* Effect10.annotateCurrentSpan({
+      "executor.tools.static_count": staticTools.size,
+      "executor.tools.dynamic_count": dynamicDeduped.length,
+      "executor.tools.result_count": result.length,
+      "executor.tools.blocked_count": blockedCount
+    });
+    return result;
+  }).pipe(Effect10.withSpan("executor.tools.list"));
+  const loadDefinitionsForSource = (sourceId) => Effect10.gen(function* () {
+    const defRows = yield* core.findMany({
+      model: "definition",
+      where: [{ field: "source_id", value: sourceId }]
+    });
+    const winners = /* @__PURE__ */ new Map();
+    for (const row of defRows) {
+      const rank = scopeRank(row);
+      const existing = winners.get(row.name);
+      if (!existing || rank < existing.rank) {
+        winners.set(row.name, { row, rank });
+      }
+    }
+    const out = {};
+    for (const [name, { row }] of winners) out[name] = row.schema;
+    return out;
+  });
+  const buildToolSchemaView = (opts) => Effect10.gen(function* () {
+    const defs = opts.sourceId ? yield* loadDefinitionsForSource(opts.sourceId).pipe(
+      Effect10.withSpan("executor.tool.schema.load_defs")
+    ) : {};
+    const attachDefs = (schema2) => {
+      if (schema2 == null || typeof schema2 !== "object") return schema2;
+      if (Object.keys(defs).length === 0) return schema2;
+      return { ...schema2, $defs: defs };
+    };
+    const inputSchema = attachDefs(opts.rawInput);
+    const outputSchema = attachDefs(opts.rawOutput);
+    const defsMap = new Map(Object.entries(defs));
+    const preview = yield* Effect10.sync(
+      () => buildToolTypeScriptPreview({ inputSchema, outputSchema, defs: defsMap })
+    ).pipe(
+      Effect10.withSpan("schema.compile.preview", {
+        attributes: {
+          "schema.kind": "tool.preview",
+          "schema.has_input": inputSchema !== void 0,
+          "schema.has_output": outputSchema !== void 0,
+          "schema.def_count": defsMap.size
+        }
+      })
+    );
+    return new ToolSchema({
+      id: ToolId.make(opts.toolId),
+      name: opts.name,
+      description: opts.description,
+      inputSchema,
+      outputSchema,
+      inputTypeScript: preview.inputTypeScript ?? void 0,
+      outputTypeScript: preview.outputTypeScript ?? void 0,
+      typeScriptDefinitions: preview.typeScriptDefinitions ?? void 0
+    });
+  });
+  const toolSchema = (toolId) => Effect10.gen(function* () {
+    const staticEntry = staticTools.get(toolId);
+    if (staticEntry) {
+      yield* Effect10.annotateCurrentSpan({
+        "executor.tool.dispatch_path": "static",
+        "executor.source_id": staticEntry.source.id,
+        "executor.source_kind": staticEntry.source.kind
+      });
+      return yield* buildToolSchemaView({
+        toolId,
+        name: staticEntry.tool.name,
+        description: staticEntry.tool.description,
+        sourceId: void 0,
+        rawInput: staticEntry.tool.inputSchema,
+        rawOutput: staticEntry.tool.outputSchema
+      });
+    }
+    const rows = yield* core.findMany({
+      model: "tool",
+      where: [{ field: "id", value: toolId }]
+    }).pipe(Effect10.withSpan("executor.tool.resolve"));
+    const row = findInnermost(rows);
+    if (!row) return null;
+    yield* Effect10.annotateCurrentSpan({
+      "executor.tool.dispatch_path": "dynamic",
+      "executor.source_id": row.source_id,
+      "executor.plugin_id": row.plugin_id
+    });
+    return yield* buildToolSchemaView({
+      toolId,
+      name: row.name,
+      description: row.description,
+      sourceId: row.source_id,
+      rawInput: decodeJsonColumn(row.input_schema),
+      rawOutput: decodeJsonColumn(row.output_schema)
+    });
+  }).pipe(
+    Effect10.withSpan("executor.tool.schema", {
+      attributes: { "mcp.tool.name": toolId }
+    })
+  );
+  const toolsDefinitions = () => Effect10.gen(function* () {
+    const rows = yield* core.findMany({ model: "definition" });
+    const winners = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = `${row.source_id}\0${row.name}`;
+      const rank = scopeRank(row);
+      const existing = winners.get(key);
+      if (!existing || rank < existing.rank) {
+        winners.set(key, { row, rank });
+      }
+    }
+    const out = {};
+    for (const { row } of winners.values()) {
+      let bucket = out[row.source_id];
+      if (!bucket) {
+        bucket = {};
+        out[row.source_id] = bucket;
+      }
+      bucket[row.name] = row.schema;
+    }
+    return out;
+  });
+  const defaultElicitationHandler = resolveElicitationHandler(
+    config.onElicitation
+  );
+  const pickHandler = (options) => options?.onElicitation ? resolveElicitationHandler(options.onElicitation) : defaultElicitationHandler;
+  const buildElicit = (toolId, args, handler) => {
+    return (request) => Effect10.gen(function* () {
+      const tid = ToolId.make(toolId);
+      const response = yield* handler({
+        toolId: tid,
+        args,
+        request
+      });
+      if (response.action !== "accept") {
+        return yield* new ElicitationDeclinedError({
+          toolId: tid,
+          action: response.action
+        });
+      }
+      return response;
+    });
+  };
+  const loadAllPolicies = () => core.findMany({ model: "tool_policy" });
+  const resolveToolPolicyForId = (toolId) => Effect10.gen(function* () {
+    const policies = yield* loadAllPolicies();
+    return resolveToolPolicy(toolId, policies, scopeRank);
+  });
+  const enforceApproval = (annotations, toolId, args, policy, handler) => Effect10.gen(function* () {
+    if (policy?.action === "approve") return;
+    const policyForcesApproval = policy?.action === "require_approval";
+    if (!policyForcesApproval && !annotations?.requiresApproval) return;
+    const tid = ToolId.make(toolId);
+    const message = annotations?.approvalDescription ? annotations.approvalDescription : policyForcesApproval && policy ? `Approve ${toolId}? (matched policy: ${policy.pattern})` : `Approve ${toolId}?`;
+    const request = new FormElicitation({
+      message,
+      requestedSchema: {}
+    });
+    const response = yield* handler({ toolId: tid, args, request });
+    if (response.action !== "accept") {
+      return yield* new ElicitationDeclinedError({
+        toolId: tid,
+        action: response.action
+      });
+    }
+  });
+  const invokeTool = (toolId, args, options) => {
+    const handler = pickHandler(options);
+    return Effect10.gen(function* () {
+      const wrapInvocationError = (effect) => effect.pipe(
+        Effect10.mapError(
+          (cause) => new ToolInvocationError({
+            toolId: ToolId.make(toolId),
+            message: cause instanceof Error ? cause.message : String(cause),
+            cause
+          })
+        )
+      );
+      const policy = yield* resolveToolPolicyForId(toolId).pipe(
+        Effect10.withSpan("executor.tool.resolve_policy")
+      );
+      if (policy?.action === "block") {
+        return yield* new ToolBlockedError({
+          toolId: ToolId.make(toolId),
+          pattern: policy.pattern
+        });
+      }
+      const staticEntry = staticTools.get(toolId);
+      if (staticEntry) {
+        yield* Effect10.annotateCurrentSpan({
+          "executor.tool.dispatch_path": "static",
+          "executor.source_id": staticEntry.source.id,
+          "executor.source_kind": staticEntry.source.kind,
+          "executor.plugin_id": staticEntry.pluginId
+        });
+        yield* enforceApproval(
+          staticEntry.tool.annotations,
+          toolId,
+          args,
+          policy,
+          handler
+        ).pipe(Effect10.withSpan("executor.tool.enforce_approval"));
+        return yield* wrapInvocationError(
+          staticEntry.tool.handler({
+            ctx: staticEntry.ctx,
+            args,
+            elicit: buildElicit(toolId, args, handler)
+          })
+        ).pipe(Effect10.withSpan("executor.tool.handler"));
+      }
+      const toolRows = yield* core.findMany({
+        model: "tool",
+        where: [{ field: "id", value: toolId }]
+      }).pipe(Effect10.withSpan("executor.tool.resolve"));
+      const row = findInnermost(toolRows);
+      if (!row) {
+        return yield* new ToolNotFoundError({
+          toolId: ToolId.make(toolId)
+        });
+      }
+      yield* Effect10.annotateCurrentSpan({
+        "executor.tool.dispatch_path": "dynamic",
+        "executor.source_id": row.source_id,
+        "executor.plugin_id": row.plugin_id
+      });
+      const runtime = runtimes.get(row.plugin_id);
+      if (!runtime) {
+        return yield* new PluginNotLoadedError({
+          pluginId: row.plugin_id,
+          toolId: ToolId.make(toolId)
+        });
+      }
+      if (!runtime.plugin.invokeTool) {
+        return yield* new NoHandlerError({
+          toolId: ToolId.make(toolId),
+          pluginId: row.plugin_id
+        });
+      }
+      let annotations;
+      if (policy?.action !== "approve" && runtime.plugin.resolveAnnotations) {
+        const map = yield* runtime.plugin.resolveAnnotations({
+          ctx: runtime.ctx,
+          sourceId: row.source_id,
+          toolRows: [row]
+        }).pipe(Effect10.withSpan("executor.tool.resolve_annotations"));
+        annotations = map[toolId];
+      }
+      yield* enforceApproval(annotations, toolId, args, policy, handler).pipe(
+        Effect10.withSpan("executor.tool.enforce_approval")
+      );
+      return yield* wrapInvocationError(
+        runtime.plugin.invokeTool({
+          ctx: runtime.ctx,
+          toolRow: row,
+          args,
+          elicit: buildElicit(toolId, args, handler)
+        })
+      ).pipe(Effect10.withSpan("executor.tool.handler"));
+    }).pipe(
+      Effect10.withSpan("executor.tool.invoke", {
+        attributes: {
+          "mcp.tool.name": toolId
+        }
+      })
+    );
+  };
+  const removeSource = (sourceId) => Effect10.gen(function* () {
+    if (staticSources.has(sourceId)) {
+      return yield* new SourceRemovalNotAllowedError({ sourceId });
+    }
+    const sourceRows = yield* core.findMany({
+      model: "source",
+      where: [{ field: "id", value: sourceId }]
+    });
+    const sourceRow = findInnermost(sourceRows);
+    if (!sourceRow) return;
+    if (!sourceRow.can_remove) {
+      return yield* new SourceRemovalNotAllowedError({ sourceId });
+    }
+    const runtime = runtimes.get(sourceRow.plugin_id);
+    yield* adapter.transaction(
+      () => Effect10.gen(function* () {
+        if (runtime?.plugin.removeSource) {
+          yield* runtime.plugin.removeSource({
+            ctx: runtime.ctx,
+            sourceId,
+            scope: sourceRow.scope_id
+          });
+        }
+        yield* deleteSourceById(
+          core,
+          sourceId,
+          sourceRow.scope_id
+        );
+      })
+    );
+  });
+  const refreshSource = (sourceId) => Effect10.gen(function* () {
+    if (staticSources.has(sourceId)) return;
+    const sourceRows = yield* core.findMany({
+      model: "source",
+      where: [{ field: "id", value: sourceId }]
+    });
+    const sourceRow = findInnermost(sourceRows);
+    if (!sourceRow) return;
+    const runtime = runtimes.get(sourceRow.plugin_id);
+    if (runtime?.plugin.refreshSource) {
+      yield* runtime.plugin.refreshSource({
+        ctx: runtime.ctx,
+        sourceId,
+        scope: sourceRow.scope_id
+      });
+    }
+  });
+  const detectionConfidenceScore = (confidence) => {
+    switch (confidence) {
+      case "high":
+        return 3;
+      case "medium":
+        return 2;
+      case "low":
+        return 1;
+    }
+  };
+  const detectSource = (url) => Effect10.gen(function* () {
+    const results = [];
+    for (const runtime of runtimes.values()) {
+      if (!runtime.plugin.detect) continue;
+      const result = yield* runtime.plugin.detect({ ctx: runtime.ctx, url }).pipe(Effect10.catch(() => Effect10.succeed(null)));
+      if (result) results.push(result);
+    }
+    return results.sort(
+      (a, b) => detectionConfidenceScore(b.confidence) - detectionConfidenceScore(a.confidence)
+    );
+  });
+  const sourceDefinitions = (sourceId) => loadDefinitionsForSource(sourceId);
+  const secretsStatus = (id) => Effect10.gen(function* () {
+    const rows = yield* secretRowsForId(id);
+    if (rows.some((row) => row.owned_by_connection_id)) return "missing";
+    for (const row of rows) {
+      if (yield* secretRouteHasBackingValue(row)) return "resolved";
+    }
+    for (const provider of secretProviders.values()) {
+      if (!provider.list) continue;
+      const entries = yield* provider.list().pipe(Effect10.catch(() => Effect10.succeed([])));
+      if (entries.some((e) => e.id === id)) return "resolved";
+    }
+    return "missing";
+  });
+  const policiesList = () => Effect10.gen(function* () {
+    const rows = yield* loadAllPolicies();
+    const sorted = [...rows].sort((a, b) => {
+      const sa = scopeRank(a);
+      const sb = scopeRank(b);
+      if (sa !== sb) return sa - sb;
+      return comparePolicyRow(a, b);
+    });
+    return sorted.map((row) => rowToToolPolicy(row));
+  }).pipe(Effect10.withSpan("executor.policies.list"));
+  const policiesCreate = (input) => Effect10.gen(function* () {
+    if (!isValidPattern(input.pattern)) {
+      return yield* new StorageError3({
+        message: `Invalid tool policy pattern "${input.pattern}". Patterns must be "*" (every tool), an exact tool id ("a.b.c"), or a trailing wildcard ("a.b.*"). Leading "*" prefixes ("*foo", "*.foo") and "**" are not supported.`,
+        cause: void 0
+      });
+    }
+    if (!isToolPolicyAction(input.action)) {
+      return yield* new StorageError3({
+        message: `Invalid tool policy action "${String(input.action)}". Expected "approve" | "require_approval" | "block".`,
+        cause: void 0
+      });
+    }
+    let position = input.position;
+    if (position === void 0) {
+      const existing = yield* core.findMany({
+        model: "tool_policy",
+        where: [{ field: "scope_id", value: input.scope }]
+      });
+      let min = null;
+      for (const row of existing) {
+        const p = row.position;
+        if (min === null || p < min) min = p;
+      }
+      position = generateKeyBetween(null, min);
+    }
+    const id = `pol_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
+    const now = /* @__PURE__ */ new Date();
+    yield* core.create({
+      model: "tool_policy",
+      data: {
+        id,
+        scope_id: input.scope,
+        pattern: input.pattern,
+        action: input.action,
+        position,
+        created_at: now,
+        updated_at: now
+      },
+      forceAllowId: true
+    });
+    return rowToToolPolicy({
+      id,
+      scope_id: input.scope,
+      pattern: input.pattern,
+      action: input.action,
+      position,
+      created_at: now,
+      updated_at: now
+    });
+  }).pipe(Effect10.withSpan("executor.policies.create"));
+  const policiesUpdate = (input) => Effect10.gen(function* () {
+    if (input.pattern !== void 0 && !isValidPattern(input.pattern)) {
+      return yield* new StorageError3({
+        message: `Invalid tool policy pattern "${input.pattern}".`,
+        cause: void 0
+      });
+    }
+    if (input.action !== void 0 && !isToolPolicyAction(input.action)) {
+      return yield* new StorageError3({
+        message: `Invalid tool policy action "${String(input.action)}".`,
+        cause: void 0
+      });
+    }
+    const rows = yield* core.findMany({
+      model: "tool_policy",
+      where: [{ field: "id", value: input.id }]
+    });
+    const row = findInnermost(rows);
+    if (!row) {
+      return yield* new StorageError3({
+        message: `Tool policy "${input.id}" not found.`,
+        cause: void 0
+      });
+    }
+    const updated = {
+      ...row,
+      pattern: input.pattern ?? row.pattern,
+      action: input.action ?? row.action,
+      position: input.position ?? row.position,
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    yield* core.update({
+      model: "tool_policy",
+      where: [
+        { field: "id", value: input.id },
+        { field: "scope_id", value: row.scope_id }
+      ],
+      update: {
+        pattern: updated.pattern,
+        action: updated.action,
+        position: updated.position,
+        updated_at: updated.updated_at
+      }
+    });
+    return rowToToolPolicy(updated);
+  }).pipe(Effect10.withSpan("executor.policies.update"));
+  const policiesRemove = (id) => core.deleteMany({
+    model: "tool_policy",
+    where: [{ field: "id", value: id }]
+  }).pipe(Effect10.asVoid, Effect10.withSpan("executor.policies.remove"));
+  const policiesResolve = (toolId) => resolveToolPolicyForId(toolId).pipe(
+    Effect10.withSpan("executor.policies.resolve")
+  );
+  const close = () => Effect10.gen(function* () {
+    for (const runtime of runtimes.values()) {
+      if (runtime.plugin.close) {
+        yield* runtime.plugin.close();
+      }
+    }
+  });
+  const base = {
+    scopes,
+    tools: {
+      list: listTools,
+      schema: toolSchema,
+      definitions: toolsDefinitions,
+      invoke: invokeTool
+    },
+    sources: {
+      list: listSources,
+      remove: removeSource,
+      refresh: refreshSource,
+      detect: detectSource,
+      definitions: sourceDefinitions
+    },
+    secrets: {
+      get: secretsGet,
+      status: secretsStatus,
+      set: secretsSet,
+      remove: secretsRemove,
+      list: secretsList,
+      providers: () => Effect10.sync(
+        () => Array.from(secretProviders.keys())
+      )
+    },
+    connections: {
+      get: connectionsGet,
+      list: connectionsList,
+      create: connectionsCreate,
+      updateTokens: connectionsUpdateTokens,
+      setIdentityLabel: connectionsSetIdentityLabel,
+      accessToken: connectionsAccessToken,
+      remove: connectionsRemove,
+      providers: () => Effect10.sync(
+        () => Array.from(connectionProviders.keys())
+      )
+    },
+    oauth: oauthBundle.service,
+    policies: {
+      list: policiesList,
+      create: policiesCreate,
+      update: policiesUpdate,
+      remove: policiesRemove,
+      resolve: policiesResolve
+    },
+    close
+  };
+  const toExecutor = (value) => value;
+  return toExecutor(Object.assign(base, extensions));
+});
+
+// src/scope.ts
+import { Schema as Schema12 } from "effect";
+var Scope = class extends Schema12.Class("Scope")({
+  id: ScopeId,
+  name: Schema12.String,
+  createdAt: Schema12.Date
+}) {
+};
+
+// src/secret-backed-value.ts
+import { Effect as Effect11, Schema as Schema13 } from "effect";
+var SecretBackedValue = Schema13.Union([
+  Schema13.String,
+  Schema13.Struct({
+    secretId: Schema13.String,
+    prefix: Schema13.optional(Schema13.String)
+  })
+]);
+var SecretBackedMap = Schema13.Record(Schema13.String, SecretBackedValue);
+var isSecretBackedRef = (value) => typeof value !== "string";
+var resolveSecretBackedMap = ({
+  values,
+  getSecret,
+  onMissing,
+  onError,
+  missing = "fail"
+}) => {
+  const entries = Object.entries(values ?? {});
+  if (entries.length === 0) return Effect11.succeed(void 0);
+  return Effect11.gen(function* () {
+    const resolved = {};
+    for (const [name, value] of entries) {
+      if (typeof value === "string") {
+        resolved[name] = value;
+        continue;
+      }
+      const secret = yield* getSecret(value.secretId).pipe(
+        Effect11.mapError((error) => onError?.(error, name, value) ?? error)
+      );
+      if (secret === null) {
+        if (missing === "drop") continue;
+        return yield* Effect11.fail(onMissing(name, value));
+      }
+      resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
+    }
+    return Object.keys(resolved).length > 0 ? resolved : void 0;
+  });
+};
+
+// src/config.ts
+var defineExecutorConfig = (config) => config;
+
+export {
+  pluginBlobStore,
+  makeInMemoryBlobStore,
+  ScopeId,
+  ToolId,
+  SecretId,
+  PolicyId,
+  ConnectionId,
+  ConnectionProviderState,
+  ConnectionRef,
+  TokenMaterial,
+  CreateConnectionInput,
+  ConnectionRefreshError,
+  UpdateConnectionTokensInput,
+  coreSchema,
+  TOOL_POLICY_ACTIONS,
+  isToolPolicyAction,
+  FormElicitation,
+  UrlElicitation,
+  ElicitationAction,
+  ElicitationResponse,
+  ElicitationDeclinedError,
+  ToolNotFoundError,
+  ToolInvocationError,
+  PluginNotLoadedError,
+  NoHandlerError,
+  ToolBlockedError,
+  SourceNotFoundError,
+  SourceRemovalNotAllowedError,
+  SecretNotFoundError,
+  SecretResolutionError,
+  SecretOwnedByConnectionError,
+  ConnectionNotFoundError,
+  ConnectionProviderNotRegisteredError,
+  ConnectionRefreshNotSupportedError,
+  ConnectionReauthRequiredError,
+  SecretRef,
+  SetSecretInput,
+  OAuthDynamicDcrStrategy,
+  OAuthAuthorizationCodeStrategy,
+  OAuthClientCredentialsStrategy,
+  OAuthStrategy,
+  OAuthProviderState,
+  OAUTH2_PROVIDER_KEY,
+  OAuthProbeError,
+  OAuthStartError,
+  OAuthCompleteError,
+  OAuthSessionNotFoundError,
+  OAUTH2_SESSION_TTL_MS,
+  OAuth2Error,
+  OAUTH2_REFRESH_SKEW_MS,
+  OAUTH2_DEFAULT_TIMEOUT_MS,
+  createPkceCodeVerifier,
+  createPkceCodeChallenge,
+  buildAuthorizationUrl,
+  exchangeAuthorizationCode,
+  exchangeClientCredentials,
+  refreshAccessToken,
+  shouldRefreshToken,
+  OAuthDiscoveryError,
+  OAuthProtectedResourceMetadataSchema,
+  OAuthAuthorizationServerMetadataSchema,
+  OAuthClientInformationSchema,
+  discoverProtectedResourceMetadata,
+  discoverAuthorizationServerMetadata,
+  registerDynamicClient,
+  beginDynamicAuthorization,
+  makeOAuth2Service,
+  matchPattern,
+  isValidPattern,
+  resolveToolPolicy,
+  resolveEffectivePolicy,
+  effectivePolicyFromSorted,
+  rowToToolPolicy,
+  ToolPolicyActionSchema,
+  ToolSchema,
+  SourceDetectionResult,
+  schemaToTypeScriptPreview,
+  schemaToTypeScriptPreviewWithDefs,
+  buildToolTypeScriptPreview,
+  collectSchemas,
+  createExecutor,
+  Scope,
+  SecretBackedValue,
+  SecretBackedMap,
+  isSecretBackedRef,
+  resolveSecretBackedMap,
+  defineExecutorConfig
+};
+//# sourceMappingURL=chunk-6LMMN2GP.js.map