@stackbone/sdk 0.1.0-alpha.6 → 0.1.0-alpha.7

package/CHANGELOG.md

@@ -7,6 +7,81 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.0-alpha.7] - 2026-06-25
+
+### Added
+
+- **Workflow-level Human-in-the-Loop (HITL) on the new `@stackbone/sdk/workflow`
+  subpath.** `requestApproval({ token, topic, payload, title, timeout, fallback })`
+  pauses a durable workflow on a Workflow SDK hook, records the pause in the
+  agent's `approvals` table (joined to the run so it shows in the inbox), and
+  races the human decision against the `timeout` — applying the `fallback`
+  (`'reject' | 'approve'`) if nobody decides. The caller gates the side-effect on
+  `decision.status === 'approved'`. The raw `defineHook` + `sleep` primitives are
+  re-exported from the same subpath as the escape hatch. Neither may run inside a
+  `"use step"` block (`.create()` is a workflow primitive that suspends the run).
+  The subpath statically imports the new OPTIONAL `workflow` peer dependency
+  (kept external by the build), so the main `@stackbone/sdk` barrel stays free of
+  it — a tool-only agent never eager-loads `workflow`.
+- **`ApprovalRequestOptions.runId`** — `client.approval.request(...)` now accepts
+  a `runId` that is written to `approvals.run_id` (FK to `runs.id`), so an
+  approval can be tied to the projected run that requested it.
+- **`eveAgent(name)` on the `@stackbone/sdk/workflow` subpath.** Addresses a
+  sibling eve agent BY NAME from a workflow `"use step"` and returns eve's `Client`
+  as-is (a thin wrapper — drive it with eve's own `.session()` / `.send()` API).
+  The name resolves to a URL through the emulator-injected `AGENT_URLS` map; each
+  request is signed with the shared `HMAC_SECRET` (timestamp-bound bearer under
+  `x-stackbone-timestamp` / `x-stackbone-workflow-signature`, verified inside a
+  5-minute drift window) so the agent's channel auth accepts the co-located hop.
+  The helper statically imports the new OPTIONAL `eve` peer dependency (kept
+  external by the build), so the main `@stackbone/sdk` barrel stays free of it.
+- **`stackbone.agent(id)` — the namespaced sibling-agent member on the ambient
+  client.** `stackbone.agent('support').session().send({ ... })` produces the same
+  signed workflow→agent call and the same eve `Client` API as the now-`@deprecated`
+  top-level `eveAgent('support')` on the `/workflow` subpath, narrowed by the same
+  augmentable `AgentRegistry` (declared names autocomplete, a typo is a compile
+  error). The crux is peer isolation: unlike `eveAgent`, the member imports NO `eve`
+  peer at module load — selecting the agent and opening a session are synchronous,
+  and only the session's already-async leaves (`send` / `stream`) resolve
+  `eve/client` via dynamic import on first use, then memoise it so conversation
+  state carries across turns. A tool-only agent that imports `@stackbone/sdk` and
+  only touches `stackbone.config` never loads `eve`. Verified by a no-peer import
+  regression test (the main barrel `index.js` statically imports neither `eve` nor
+  `workflow`).
+- **`stackbone.agent(id).session()` is now a DROP-IN twin of eve's native
+  `ClientSession`.** A workflow written against the eager `eveAgent(...)` path keeps
+  compiling verbatim when it swaps to `stackbone.agent(...)`: `session.send<T>(...)`
+  returns eve's `MessageResponse<T>` (so both `.result()` — typed `.data` — and
+  `for await...of` work), `session.session(state)` accepts eve's nominal
+  `SessionState` (`{ continuationToken?, sessionId?, streamIndex }`), and
+  `session.state` exposes the advanced cursor to persist between turns. These
+  peer-free structural mirrors are exported from the main barrel as
+  `EveMessageResponse` / `EveMessageResult` / `EveSessionState` / `EveStreamEvent` /
+  `SendTurnInput` (plus `AgentAccessor` / `LazyAgentClient` / `LazyAgentSession` /
+  `AgentRegistry`) so a workflow can name the handle, the response, the cursor and
+  the forwarded stream frame without reaching for the optional `eve` peer.
+  Previously the lazy session typed `send` as `Promise<unknown>` and omitted
+  `state`, so those usages did not type-check — only the eager path did.
+
+### Deprecated
+
+- **`eveAgent(name)`** (on the `@stackbone/sdk/workflow` subpath) in favour of the
+  namespaced `stackbone.agent(id)` from the main barrel. The old export still works
+  and is byte-identical on the wire; it just resolves the `eve` peer eagerly (the
+  subpath already imports it) instead of lazily.
+
+### Documentation
+
+- **Public docs + starter templates moved to the namespaced reach-by-id surface.**
+  The developer wiki gains a dedicated `stackbone.agent` page, documents
+  `stackbone.connection(id)` alongside the workspace-broker `client.legacyConnections`,
+  and shows the ambient `stackbone` handle with both reach-by-id members in the SDK
+  overview — each with a note that the top-level `eveAgent(...)` / bare
+  `connection(...)` forms are deprecated aliases. The starter's `AGENTS.md` now
+  models `stackbone.agent(...)` / `stackbone.connection(...)` for agent-to-agent and
+  connector calls. The CLI's inline `stackbone docs` bundle is regenerated from the
+  wiki so the new surface ships with the next CLI release.
+
 ## [0.1.0-alpha.6] - 2026-06-17
 
 ### Added

package/call-connector-CYDw_yG5.d.cts

@@ -0,0 +1,118 @@
+/**
+ * WHO a connector call is made on behalf of — the scoping principal the broker
+ * keys its credential cache/grant against. A STRUCTURAL mirror of the broker
+ * contract's `@stackbone/connect-contract` `Principal` union (app / user /
+ * client-credentials / jwt-bearer); defined locally rather than imported so the
+ * SDK connect surface stays a self-contained leaf (the sibling eve adapter follows
+ * the same discipline — it never pulls the platform contract into the published
+ * SDK tarball). It is structurally compatible, so a value typed against the
+ * contract's `Principal` is assignable here and vice-versa.
+ */
+type Principal = {
+    readonly type: 'app';
+} | {
+    readonly type: 'user';
+    readonly id: string;
+    readonly issuer: string;
+    readonly attributes?: Readonly<Record<string, string | readonly string[]>>;
+} | {
+    readonly type: 'client-credentials';
+    readonly serviceAccountId: string;
+} | {
+    readonly type: 'jwt-bearer';
+    readonly subject: string;
+    readonly issuer: string;
+};
+
+/** Options accepted by `callConnector` / `connection(...).call`. */
+interface CallConnectorOptions {
+    /**
+     * WHO the connector call is made on behalf of. Defaults to `{ type: 'app' }`
+     * (the agent's own service-account credential). A `user` principal scopes the
+     * broker token issuer to that end user; `client-credentials` / `jwt-bearer` are
+     * the broker's M2M auth modes.
+     */
+    readonly principal?: Principal;
+}
+/**
+ * An `Error` carrying the broker's machine-readable `code` so a workflow matches
+ * the failure BY CODE STRING (never `instanceof` — under bundling the SDK and the
+ * workflow can hold different class identities; the code is the stable signal).
+ */
+interface ConnectorCallError extends Error {
+    /** The broker error code (`invalid_args`, `credential_error`, `timeout`, …). */
+    readonly code: string;
+}
+/**
+ * Call a Stackbone Connect connector operation directly from a workflow.
+ *
+ * POSTs `{ connector, operation, args, principal, installationId }` to the
+ * agent-facing broker (`POST /api/connect/execute`) with HMAC scheme-A headers.
+ * On `{ ok: true, output }` it returns the operation `output`; on
+ * `{ ok: false, error }` (or any non-2xx) it THROWS a `ConnectorCallError` whose
+ * `.code` is the broker error code and `.message` the broker message.
+ *
+ * ```ts
+ * const channels = await callConnector('slack', 'conversations.list');
+ * await callConnector('slack', 'chat.postMessage', { channel: 'C123', text: 'hi' });
+ * ```
+ *
+ * @param connector The connect connector id registered in Studio.
+ * @param operation The operation / tool id to run on that connector.
+ * @param args      The operation arguments (path/query/body params). Defaults `{}`.
+ * @param opts      Optional `{ principal }` — defaults to `{ type: 'app' }`.
+ */
+declare function callConnector(connector: string, operation: string, args?: Readonly<Record<string, unknown>>, opts?: CallConnectorOptions): Promise<unknown>;
+/** The dynamic escape hatch present on every `connection(id)` handle. */
+interface ConnectorHandle {
+    /**
+     * Run ANY operation on this connector by id — the untyped escape hatch, always
+     * available (use it for an operation id that is not a JS identifier, e.g. a
+     * dotted `chat.postMessage`, or a connector with no generated types). Sugar for
+     * `callConnector(id, operation, args, opts)`.
+     */
+    call(operation: string, args?: Readonly<Record<string, unknown>>, opts?: CallConnectorOptions): Promise<unknown>;
+}
+/**
+ * Augmentable registry of TYPED connector operations, keyed by the VERBATIM
+ * connector id (`'stub-mail'`, `'slack'`). The Stackbone Connect type generator
+ * (`stackbone dev` writes `.stackbone/connect.d.ts`) MERGES one member per connector
+ * into this interface via a `declare module` augmentation, each a map of the
+ * connector's operations → typed `(args) => Promise<output>`, derived from the
+ * introspected JSON Schema. Empty by default — with no generated types,
+ * `connection(id)` offers only the dynamic `.call(...)`.
+ *
+ * Same id-keyed-registry mechanism as `eveAgent`'s `AgentRegistry`: the selection
+ * style is unified — address an entity by its verbatim id, get a typed handle.
+ */
+interface StackboneConnections {
+}
+/**
+ * The typed handle for a connector id: its generated operations (when the id is a
+ * known key of `StackboneConnections`) intersected with the dynamic `.call` escape
+ * hatch (always present). An unknown id resolves to just `ConnectorHandle`.
+ */
+type ConnectorOf<Id extends string> = (Id extends keyof StackboneConnections ? StackboneConnections[Id] : unknown) & ConnectorHandle;
+/**
+ * The exported `connection`: select a connector by its verbatim id and get a typed
+ * handle. A known id (a key of the generated `StackboneConnections`) yields its
+ * typed operations + `.call`; any other string yields the dynamic `ConnectorHandle`.
+ */
+interface ConnectionAccessor {
+    <Id extends keyof StackboneConnections>(id: Id): ConnectorOf<Id>;
+    (id: string): ConnectorHandle;
+}
+/**
+ * Call Stackbone Connect connectors. Select by verbatim id, then call an operation —
+ * typed when `.stackbone/connect.d.ts` is generated, dynamic via `.call` always:
+ *
+ * ```ts
+ * await connection('stub-mail').sendMail({ to, subject, body }); // typed
+ * await connection('slack').call('chat.postMessage', { ... });   // dynamic escape hatch
+ * ```
+ *
+ * Mirrors `eveAgent('agent-name')`: one id-keyed selection style across the SDK.
+ */
+declare const connection: ConnectionAccessor;
+
+export { type CallConnectorOptions as C, type Principal as P, type StackboneConnections as S, type ConnectionAccessor as a, type ConnectorCallError as b, type ConnectorHandle as c, callConnector as d, connection as e };

package/call-connector-CYDw_yG5.d.ts

@@ -0,0 +1,118 @@
+/**
+ * WHO a connector call is made on behalf of — the scoping principal the broker
+ * keys its credential cache/grant against. A STRUCTURAL mirror of the broker
+ * contract's `@stackbone/connect-contract` `Principal` union (app / user /
+ * client-credentials / jwt-bearer); defined locally rather than imported so the
+ * SDK connect surface stays a self-contained leaf (the sibling eve adapter follows
+ * the same discipline — it never pulls the platform contract into the published
+ * SDK tarball). It is structurally compatible, so a value typed against the
+ * contract's `Principal` is assignable here and vice-versa.
+ */
+type Principal = {
+    readonly type: 'app';
+} | {
+    readonly type: 'user';
+    readonly id: string;
+    readonly issuer: string;
+    readonly attributes?: Readonly<Record<string, string | readonly string[]>>;
+} | {
+    readonly type: 'client-credentials';
+    readonly serviceAccountId: string;
+} | {
+    readonly type: 'jwt-bearer';
+    readonly subject: string;
+    readonly issuer: string;
+};
+
+/** Options accepted by `callConnector` / `connection(...).call`. */
+interface CallConnectorOptions {
+    /**
+     * WHO the connector call is made on behalf of. Defaults to `{ type: 'app' }`
+     * (the agent's own service-account credential). A `user` principal scopes the
+     * broker token issuer to that end user; `client-credentials` / `jwt-bearer` are
+     * the broker's M2M auth modes.
+     */
+    readonly principal?: Principal;
+}
+/**
+ * An `Error` carrying the broker's machine-readable `code` so a workflow matches
+ * the failure BY CODE STRING (never `instanceof` — under bundling the SDK and the
+ * workflow can hold different class identities; the code is the stable signal).
+ */
+interface ConnectorCallError extends Error {
+    /** The broker error code (`invalid_args`, `credential_error`, `timeout`, …). */
+    readonly code: string;
+}
+/**
+ * Call a Stackbone Connect connector operation directly from a workflow.
+ *
+ * POSTs `{ connector, operation, args, principal, installationId }` to the
+ * agent-facing broker (`POST /api/connect/execute`) with HMAC scheme-A headers.
+ * On `{ ok: true, output }` it returns the operation `output`; on
+ * `{ ok: false, error }` (or any non-2xx) it THROWS a `ConnectorCallError` whose
+ * `.code` is the broker error code and `.message` the broker message.
+ *
+ * ```ts
+ * const channels = await callConnector('slack', 'conversations.list');
+ * await callConnector('slack', 'chat.postMessage', { channel: 'C123', text: 'hi' });
+ * ```
+ *
+ * @param connector The connect connector id registered in Studio.
+ * @param operation The operation / tool id to run on that connector.
+ * @param args      The operation arguments (path/query/body params). Defaults `{}`.
+ * @param opts      Optional `{ principal }` — defaults to `{ type: 'app' }`.
+ */
+declare function callConnector(connector: string, operation: string, args?: Readonly<Record<string, unknown>>, opts?: CallConnectorOptions): Promise<unknown>;
+/** The dynamic escape hatch present on every `connection(id)` handle. */
+interface ConnectorHandle {
+    /**
+     * Run ANY operation on this connector by id — the untyped escape hatch, always
+     * available (use it for an operation id that is not a JS identifier, e.g. a
+     * dotted `chat.postMessage`, or a connector with no generated types). Sugar for
+     * `callConnector(id, operation, args, opts)`.
+     */
+    call(operation: string, args?: Readonly<Record<string, unknown>>, opts?: CallConnectorOptions): Promise<unknown>;
+}
+/**
+ * Augmentable registry of TYPED connector operations, keyed by the VERBATIM
+ * connector id (`'stub-mail'`, `'slack'`). The Stackbone Connect type generator
+ * (`stackbone dev` writes `.stackbone/connect.d.ts`) MERGES one member per connector
+ * into this interface via a `declare module` augmentation, each a map of the
+ * connector's operations → typed `(args) => Promise<output>`, derived from the
+ * introspected JSON Schema. Empty by default — with no generated types,
+ * `connection(id)` offers only the dynamic `.call(...)`.
+ *
+ * Same id-keyed-registry mechanism as `eveAgent`'s `AgentRegistry`: the selection
+ * style is unified — address an entity by its verbatim id, get a typed handle.
+ */
+interface StackboneConnections {
+}
+/**
+ * The typed handle for a connector id: its generated operations (when the id is a
+ * known key of `StackboneConnections`) intersected with the dynamic `.call` escape
+ * hatch (always present). An unknown id resolves to just `ConnectorHandle`.
+ */
+type ConnectorOf<Id extends string> = (Id extends keyof StackboneConnections ? StackboneConnections[Id] : unknown) & ConnectorHandle;
+/**
+ * The exported `connection`: select a connector by its verbatim id and get a typed
+ * handle. A known id (a key of the generated `StackboneConnections`) yields its
+ * typed operations + `.call`; any other string yields the dynamic `ConnectorHandle`.
+ */
+interface ConnectionAccessor {
+    <Id extends keyof StackboneConnections>(id: Id): ConnectorOf<Id>;
+    (id: string): ConnectorHandle;
+}
+/**
+ * Call Stackbone Connect connectors. Select by verbatim id, then call an operation —
+ * typed when `.stackbone/connect.d.ts` is generated, dynamic via `.call` always:
+ *
+ * ```ts
+ * await connection('stub-mail').sendMail({ to, subject, body }); // typed
+ * await connection('slack').call('chat.postMessage', { ... });   // dynamic escape hatch
+ * ```
+ *
+ * Mirrors `eveAgent('agent-name')`: one id-keyed selection style across the SDK.
+ */
+declare const connection: ConnectionAccessor;
+
+export { type CallConnectorOptions as C, type Principal as P, type StackboneConnections as S, type ConnectionAccessor as a, type ConnectorCallError as b, type ConnectorHandle as c, callConnector as d, connection as e };

package/connect.cjs

@@ -0,0 +1,270 @@
+'use strict';
+
+var connections = require('eve/connections');
+var crypto = require('crypto');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var TIMESTAMP_HEADER = "x-stackbone-timestamp";
+var SIGNATURE_HEADER = "x-stackbone-workflow-signature";
+function signBrokerHeaders() {
+  const secret = process.env["HMAC_SECRET"] ?? "";
+  const timestamp = String(Date.now());
+  const signature = crypto.createHmac("sha256", secret).update(timestamp).digest("hex");
+  return {
+    [TIMESTAMP_HEADER]: timestamp,
+    [SIGNATURE_HEADER]: signature
+  };
+}
+__name(signBrokerHeaders, "signBrokerHeaders");
+function brokerBaseUrl() {
+  const url = process.env["STACKBONE_API_URL"];
+  if (!url) {
+    throw new Error("STACKBONE_API_URL is not set. The Stackbone runtime injects the broker base URL; run this agent through `stackbone dev`.");
+  }
+  return url.replace(/\/+$/, "");
+}
+__name(brokerBaseUrl, "brokerBaseUrl");
+function installationId() {
+  const id = process.env["STACKBONE_INSTALLATION_ID"];
+  if (!id) {
+    throw new Error("STACKBONE_INSTALLATION_ID is not set. The Stackbone runtime injects it; run this agent through `stackbone dev`.");
+  }
+  return id;
+}
+__name(installationId, "installationId");
+
+// src/surfaces/external/connect/connect.ts
+var TOKEN_PATH = "/api/connect/token";
+function brokerCodeToEveError(connectorId, code, message) {
+  switch (code) {
+    case "no_token":
+    case "user_authorization_required":
+      return new connections.ConnectionAuthorizationRequiredError(connectorId, message ? {
+        message
+      } : void 0);
+    case "connector_installation_required":
+    case "app_not_installed":
+      return new connections.ConnectionAuthorizationFailedError(connectorId, {
+        ...message ? {
+          message
+        } : {},
+        reason: "app_not_installed",
+        retryable: false
+      });
+    case "principal_required":
+      return new connections.ConnectionAuthorizationFailedError(connectorId, {
+        ...message ? {
+          message
+        } : {},
+        reason: "principal_required",
+        retryable: false
+      });
+    default:
+      return new connections.ConnectionAuthorizationFailedError(connectorId, {
+        message: message ?? `Stackbone Connect broker rejected the token request (code "${code}").`,
+        reason: code,
+        retryable: false
+      });
+  }
+}
+__name(brokerCodeToEveError, "brokerCodeToEveError");
+async function readBrokerError(response) {
+  const body = await response.json().catch(() => null);
+  if (body && typeof body.code === "string") {
+    return {
+      code: body.code,
+      ...body.message !== void 0 ? {
+        message: body.message
+      } : {}
+    };
+  }
+  return {
+    code: "credential_error",
+    message: `Broker responded ${response.status}.`
+  };
+}
+__name(readBrokerError, "readBrokerError");
+async function fetchBrokerToken(connectorId) {
+  const body = JSON.stringify({
+    connector: connectorId,
+    principal: {
+      type: "app"
+    },
+    installationId: installationId()
+  });
+  let response;
+  try {
+    response = await fetch(`${brokerBaseUrl()}${TOKEN_PATH}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...signBrokerHeaders()
+      },
+      body
+    });
+  } catch (cause) {
+    throw new connections.ConnectionAuthorizationFailedError(connectorId, {
+      message: `Stackbone Connect broker is unreachable: ${cause instanceof Error ? cause.message : String(cause)}`,
+      reason: "execute_failed",
+      retryable: true
+    });
+  }
+  if (!response.ok) {
+    const error = await readBrokerError(response);
+    throw brokerCodeToEveError(connectorId, error.code, error.message);
+  }
+  const minted = await response.json().catch(() => null);
+  if (!minted || typeof minted.token !== "string") {
+    throw new connections.ConnectionAuthorizationFailedError(connectorId, {
+      message: "Stackbone Connect broker returned a malformed token response.",
+      reason: "invalid_output",
+      retryable: false
+    });
+  }
+  return minted.expiresAt !== void 0 ? {
+    token: minted.token,
+    expiresAt: minted.expiresAt
+  } : {
+    token: minted.token
+  };
+}
+__name(fetchBrokerToken, "fetchBrokerToken");
+async function evictBrokerToken(connectorId) {
+  try {
+    await fetch(`${brokerBaseUrl()}${TOKEN_PATH.replace(/\/token$/, "/evict")}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...signBrokerHeaders()
+      },
+      body: JSON.stringify({
+        connector: connectorId,
+        principal: {
+          type: "app"
+        },
+        installationId: process.env["STACKBONE_INSTALLATION_ID"]
+      })
+    });
+  } catch {
+  }
+}
+__name(evictBrokerToken, "evictBrokerToken");
+function connect(connectorId) {
+  return {
+    principalType: "app",
+    stackboneConnect: {
+      connector: connectorId
+    },
+    getToken(_opts) {
+      return fetchBrokerToken(connectorId);
+    },
+    evict(_opts) {
+      return evictBrokerToken(connectorId);
+    }
+  };
+}
+__name(connect, "connect");
+
+// src/surfaces/external/connect/channel-helpers.ts
+function withConnect(definition, connectorId) {
+  return {
+    ...definition,
+    auth: connect(connectorId)
+  };
+}
+__name(withConnect, "withConnect");
+function connectHeaders(connectorId, headerName = "X-Api-Key") {
+  const auth = connect(connectorId);
+  return async () => {
+    const { token } = await auth.getToken({
+      principal: {
+        type: "app"
+      },
+      connection: {
+        url: ""
+      }
+    });
+    return {
+      [headerName]: token
+    };
+  };
+}
+__name(connectHeaders, "connectHeaders");
+
+// src/surfaces/external/connect/call-connector.ts
+var EXECUTE_PATH = "/api/connect/execute";
+function connectorCallError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+__name(connectorCallError, "connectorCallError");
+function errorFromBody(status, body) {
+  if (body && body.ok === false && body.error && typeof body.error.code === "string") {
+    return connectorCallError(body.error.code, body.error.message ?? `Stackbone Connect broker rejected the call (code "${body.error.code}").`);
+  }
+  return connectorCallError("credential_error", `Stackbone Connect broker responded ${status}.`);
+}
+__name(errorFromBody, "errorFromBody");
+async function callConnector(connector, operation, args, opts) {
+  const principal = opts?.principal ?? {
+    type: "app"
+  };
+  const url = `${brokerBaseUrl()}${EXECUTE_PATH}`;
+  const body = JSON.stringify({
+    connector,
+    operation,
+    args: args ?? {},
+    principal,
+    installationId: installationId()
+  });
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...signBrokerHeaders()
+      },
+      body
+    });
+  } catch (cause) {
+    throw connectorCallError("execute_failed", `Stackbone Connect broker is unreachable: ${cause instanceof Error ? cause.message : String(cause)}`);
+  }
+  const parsed = await response.json().catch(() => null);
+  if (!response.ok || parsed && parsed.ok === false) {
+    throw errorFromBody(response.status, parsed ?? null);
+  }
+  if (!parsed || parsed.ok !== true) {
+    throw connectorCallError("invalid_output", "Stackbone Connect broker returned a malformed execute response.");
+  }
+  return parsed.output;
+}
+__name(callConnector, "callConnector");
+var connectorHandle = /* @__PURE__ */ __name((id) => new Proxy(/* @__PURE__ */ Object.create(null), {
+  get(_target, prop) {
+    if (typeof prop !== "string" || prop === "then") return void 0;
+    if (prop === "call") {
+      return (operation, args, opts) => callConnector(id, operation, args, opts);
+    }
+    return (args, opts) => callConnector(id, prop, args, opts);
+  }
+}), "connectorHandle");
+var connection = /* @__PURE__ */ __name((id) => connectorHandle(id), "connection");
+
+Object.defineProperty(exports, "ConnectionAuthorizationFailedError", {
+  enumerable: true,
+  get: function () { return connections.ConnectionAuthorizationFailedError; }
+});
+Object.defineProperty(exports, "ConnectionAuthorizationRequiredError", {
+  enumerable: true,
+  get: function () { return connections.ConnectionAuthorizationRequiredError; }
+});
+exports.callConnector = callConnector;
+exports.connect = connect;
+exports.connectHeaders = connectHeaders;
+exports.connection = connection;
+exports.withConnect = withConnect;
+//# sourceMappingURL=connect.cjs.map
+//# sourceMappingURL=connect.cjs.map