@composio/client 2.0.0-rc.11 → 2.0.0-rc.13

package/dist/effect.mjs

@@ -0,0 +1,1572 @@
+import { h as makeAPIErrorMessage, m as errorDetails, s as ComposioError } from "./error-D9cG225M.mjs";
+import { A as resolveHTTPURL, C as inspectDeprecation, D as callerPlacedCredential, E as assertCredentialTransport, M as mergeHeaders, O as carriesCredentials, S as inspectDeprecatedInputs, T as SCHEME_HEADERS, _ as schemeForRequest, a as TOO_MANY_REDIRECTS, c as buildURL, d as path, f as printableURL, g as safeJSON, h as rewriteForRedirect, i as REDIRECT_STATUSES, j as buildHeaders, k as parseHTTPURL, m as retryDelayMillis, n as generatedOperation, o as buildBody, r as OPAQUE_REDIRECT, s as buildRequestHeaders, t as GENERATED_OPERATIONS, v as shouldRetryResponse, w as matchOperation, x as VERSION, y as validatePositiveInteger } from "./generated-operations-CtVNMBUj.mjs";
+import { r as classifySuccessBody, t as GENERATED_DEPRECATED_INPUTS } from "./generated-deprecated-inputs-LDMdNcg5.mjs";
+import { i as standardNextCursor, n as assertPageItems, r as isFinalCursor, t as assertCursorAdvanced } from "./pagination-rules-uMUdPq_7.mjs";
+import { Config, Context, Data, Effect, Exit, Layer, Match, Option, Predicate, Redacted, Result, Stream, Tracer } from "effect";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as HttpClient from "effect/http/HttpClient";
+import * as Headers from "effect/http/Headers";
+import * as Schema from "effect/Schema";
+import * as HttpBody from "effect/http/HttpBody";
+import { StatusCodeError, isHttpClientError } from "effect/http/HttpClientError";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as UrlParams from "effect/http/UrlParams";
+
+//#region src/effect/credentials.ts
+/**
+* How the Effect kernel holds credentials, and how it keeps them out of what
+* the transport records.
+*
+* Which credential a request carries, and where it may go, is decided by the
+* compat kernel's own functions (`../compat/credentials.ts`); nothing here
+* restates a rule. What is specific to this surface is the wrapping — a
+* credential is a `Redacted` for as long as the client holds it — and Effect's
+* redaction list, which knows `x-api-key` and not the other two schemes.
+*/
+const reveal = (credential) => credential === null ? null : Redacted.value(credential);
+/** The credentials in the plain form the compat functions take. Never stored. */
+const revealCredentials = (held) => ({
+	apiKey: reveal(held.apiKey),
+	userApiKey: reveal(held.userApiKey),
+	orgApiKey: reveal(held.orgApiKey)
+});
+const OPTION_HEADERS = {
+	apiKey: SCHEME_HEADERS.ApiKeyAuth,
+	userApiKey: SCHEME_HEADERS.UserApiKeyAuth,
+	orgApiKey: SCHEME_HEADERS.OrgApiKeyAuth
+};
+const CREDENTIAL_OPTIONS = Object.keys(OPTION_HEADERS);
+/** Whether the platform's `Headers` takes `value` under `name`. Its refusal quotes the value, so it stays here. */
+const isSendable = (name, value) => {
+	try {
+		new globalThis.Headers().set(name, value);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* The option naming a credential no header can carry (an interior CR, LF or
+* NUL, or a character outside Latin-1), or `undefined` when all of them can be
+* sent. The answer is the option's name and never the value.
+*/
+const unsendableCredential = (held) => CREDENTIAL_OPTIONS.find((option) => {
+	const credential = held[option];
+	return credential !== null && !isSendable(OPTION_HEADERS[option], Redacted.value(credential));
+});
+const CREDENTIAL_HEADER_NAMES = Object.values(SCHEME_HEADERS);
+/** The extended list for each list seen, so a request does not rebuild it. */
+const extended = /* @__PURE__ */ new WeakMap();
+/**
+* Effect's redaction list with every credential header name on it, so a span
+* attribute or a rendering of the request made while the transport handles it
+* shows `<redacted>` for all three.
+*
+* The list in context is extended, not replaced: an application that added
+* names of its own keeps them.
+*/
+const withCredentialHeaderNames = (names) => {
+	const known = extended.get(names);
+	if (known !== void 0) return known;
+	const all = [...names, ...CREDENTIAL_HEADER_NAMES.filter((name) => !Headers.isRedactedName(name, names))];
+	extended.set(names, all);
+	return all;
+};
+
+//#endregion
+//#region src/effect/errors.ts
+/**
+* The failure model of the Effect surface: flat tagged errors, one per status
+* class the compat client distinguishes, plus the failures that have no HTTP
+* status at all.
+*
+* Every error is built with `Data.TaggedError`, so recovery is
+* `Effect.catchTag` on a tag rather than a walk through a cause chain, and no
+* Schema module is evaluated to construct one.
+*
+* What an error value may hold is deliberately narrow. It names the request by
+* its method and a label built from the operation template — never the
+* `HttpClientRequest`, whose headers carry the credential, and never the
+* transport's own error, which holds that request. A success body is where
+* this API returns secrets, so the decode error carries where and what kind,
+* not the body.
+*/
+var BadRequestError = class extends Data.TaggedError("@composio/client/BadRequestError") {};
+var AuthenticationError = class extends Data.TaggedError("@composio/client/AuthenticationError") {};
+var PermissionDeniedError = class extends Data.TaggedError("@composio/client/PermissionDeniedError") {};
+var NotFoundError = class extends Data.TaggedError("@composio/client/NotFoundError") {};
+var ConflictError = class extends Data.TaggedError("@composio/client/ConflictError") {};
+var UnprocessableEntityError = class extends Data.TaggedError("@composio/client/UnprocessableEntityError") {};
+var RateLimitError = class extends Data.TaggedError("@composio/client/RateLimitError") {};
+/** Any status of 500 and above. */
+var InternalServerError = class extends Data.TaggedError("@composio/client/InternalServerError") {};
+/** A non-success status none of the other classes names. */
+var APIError = class extends Data.TaggedError("@composio/client/APIError") {};
+/**
+* The request never produced a response: the transport failed below HTTP.
+*
+* The transport's error is reduced to `reason` (which of its failure kinds it
+* was) and `description` (its own text, or its cause's messages).
+*/
+var APIConnectionError = class extends Data.TaggedError("@composio/client/APIConnectionError") {};
+/** An attempt outlived its time budget. */
+var APIConnectionTimeoutError = class extends Data.TaggedError("@composio/client/APIConnectionTimeoutError") {};
+/** A success response whose body is not what it claims to be. */
+var DecodeError = class extends Data.TaggedError("@composio/client/DecodeError") {};
+/**
+* The client or the call is set up in a way no request can be made from: a
+* credentialed origin that cannot carry a credential, a path parameter that
+* would rewrite the path, a body that does not serialize. Retrying cannot
+* change the answer.
+*/
+var ConfigurationError = class extends Data.TaggedError("@composio/client/ConfigurationError") {};
+/** What a caller is told when a request could not be built and the reason is not the kernel's own to give. */
+const UNBUILDABLE = "The request could not be built: a header value, the URL or the body is not valid.";
+/**
+* Whatever a setup step threw, as a {@link ConfigurationError}.
+*
+* The message is copied only from an error the kernel itself raised: a
+* rejected path parameter or option, an origin that cannot carry a credential,
+* a pagination rule. Anything else comes from the platform or from the
+* caller's own objects, and its text is not this client's to repeat. The
+* platform's `Headers` quotes the value it refuses, and that value can be a
+* credential.
+*/
+const configurationErrorFrom = (cause) => new ConfigurationError({ message: cause instanceof ComposioError ? cause.message : UNBUILDABLE });
+/** The status mapping of the compat client's `APIError.generate`. */
+const apiErrorFromResponse = (fields) => {
+	const { status } = fields;
+	if (status === 400) return new BadRequestError(fields);
+	if (status === 401) return new AuthenticationError(fields);
+	if (status === 403) return new PermissionDeniedError(fields);
+	if (status === 404) return new NotFoundError(fields);
+	if (status === 409) return new ConflictError(fields);
+	if (status === 422) return new UnprocessableEntityError(fields);
+	if (status === 429) return new RateLimitError(fields);
+	if (status >= 500) return new InternalServerError(fields);
+	return new APIError(fields);
+};
+/**
+* Every tag this surface fails with, and whether it is a status class. Typed
+* against the union, so an error class added to it and not here does not compile.
+*/
+const TAG_KINDS = {
+	"@composio/client/BadRequestError": "status",
+	"@composio/client/AuthenticationError": "status",
+	"@composio/client/PermissionDeniedError": "status",
+	"@composio/client/NotFoundError": "status",
+	"@composio/client/ConflictError": "status",
+	"@composio/client/UnprocessableEntityError": "status",
+	"@composio/client/RateLimitError": "status",
+	"@composio/client/InternalServerError": "status",
+	"@composio/client/APIError": "status",
+	"@composio/client/APIConnectionError": "other",
+	"@composio/client/APIConnectionTimeoutError": "other",
+	"@composio/client/DecodeError": "other",
+	"@composio/client/ConfigurationError": "other"
+};
+const tagOf = (value) => Predicate.hasProperty(value, "_tag") && typeof value._tag === "string" ? value._tag : void 0;
+const kindOf = (value) => {
+	const tag = tagOf(value);
+	return tag !== void 0 && Object.hasOwn(TAG_KINDS, tag) ? TAG_KINDS[tag] : void 0;
+};
+/**
+* Whether a value is an error for a non-success HTTP response, of any status
+* class. Structural, so it holds across duplicated copies of this module.
+*/
+const isAPIError = (value) => kindOf(value) === "status";
+/** Whether a value is any error this surface produces. Structural, like {@link isAPIError}. */
+const isComposioError = (value) => kindOf(value) !== void 0;
+
+//#endregion
+//#region src/effect/decode.ts
+/**
+* Opt-in response validation: a success body checked against the operation's
+* generated schema.
+*
+* Decoding is off unless a call or the client asks for it, and the schemas are
+* not this module's to find. They arrive as a loader table the caller imports
+* from `@composio/client/effect/schemas` and hands to the client, one dynamic
+* `import()` per operation. Nothing the default entry reaches names that table
+* or a schema module, so a client that never decodes never evaluates one, and
+* a bundle of an application that never imports the table contains none.
+*
+* A schema here is a validator, not a parser. The caller gets the body exactly
+* as it was parsed — a field the API returns ahead of the spec is not
+* stripped — and this module's only answer is what, if anything, is wrong with
+* it: where, and what kind of problem. Never the value found there, and never
+* Effect's own rendering of the failure, which quotes it; a success body is
+* where this API returns secrets.
+*/
+/** What a client or a call that asks for decoding is told when no table was supplied. */
+const SCHEMAS_MISSING = "Decoding needs the response schemas, and this client was given none: import { schemaLoaders } from '@composio/client/effect/schemas' and pass it as the `schemas` option.";
+/** The same configuration message before dispatch and after a failed dynamic import. */
+const schemaUnavailableMessage = (key) => `The response schema of '${key}' could not be loaded.`;
+const segment = (key) => typeof key === "symbol" ? String(key) : key;
+/**
+* The leaves of an issue tree, each with the path the tree led to it by. The
+* leaf's kind is its tag: `MissingKey`, `InvalidType`, `InvalidValue`, …
+*/
+const leaves = (issue, path) => {
+	const leaf = ({ _tag }) => [{
+		path,
+		kind: _tag
+	}];
+	return Match.valueTags(issue, {
+		Pointer: (pointer) => leaves(pointer.issue, [...path, ...pointer.path.map(segment)]),
+		Composite: (composite) => composite.issues.flatMap((child) => leaves(child, path)),
+		AnyOf: (anyOf) => anyOf.issues.length === 0 ? leaf(anyOf) : anyOf.issues.flatMap((child) => leaves(child, path)),
+		Filter: (filter) => leaves(filter.issue, path),
+		Encoding: (encoding) => leaves(encoding.issue, path),
+		InvalidType: leaf,
+		InvalidValue: leaf,
+		MissingKey: leaf,
+		UnexpectedKey: leaf,
+		Forbidden: leaf,
+		OneOf: leaf
+	});
+};
+/** A union reports a problem once per member it tried; one mention of each is enough. */
+const distinct = (issues) => [...new Map(issues.map((issue) => [JSON.stringify([issue.path, issue.kind]), issue])).values()];
+/** What is wrong with `body` as a value of `schema`; empty when nothing is. */
+const issuesOf = (schema, body) => {
+	const result = Schema.decodeUnknownResult(schema, { errors: "all" })(body);
+	return Result.isFailure(result) ? distinct(leaves(result.failure.issue, [])) : [];
+};
+/**
+* Validates a success body against the response schema of the operation
+* `key` names (`toolkits.list`), loading the schema from `loaders` first.
+* Succeeds with the issues found, empty for a body that is what the spec says.
+*
+* A schema that cannot be loaded is a broken installation — a bundle that left
+* the module out — and no request would change that.
+*/
+const responseIssues = (loaders, key, body) => {
+	const unavailable = () => new ConfigurationError({ message: schemaUnavailableMessage(key) });
+	const load = loaders[key];
+	if (load === void 0) return Effect.fail(unavailable());
+	return Effect.map(Effect.tryPromise({
+		try: load,
+		catch: unavailable
+	}), (schema) => issuesOf(schema, body));
+};
+
+//#endregion
+//#region src/effect/deprecation.ts
+/**
+* Deprecation notices on the Effect surface.
+*
+* Deciding that a notice exists, wording it, and remembering that it was
+* already given are the compat module's functions (`../compat/deprecation.ts`),
+* called here with the same tables. This module owns only the way out: a
+* notice is a `Warn` record on Effect's logger, so the application's logger
+* and minimum log level decide what becomes of it.
+*/
+const makeNoticeRecord = (mode) => ({
+	mode: mode ?? "warn",
+	seen: /* @__PURE__ */ new Set()
+});
+/** The compat inspectors report through a callback; this collects what one of them said. */
+const warnings = (inspect) => {
+	const messages = [];
+	inspect((message) => messages.push(message));
+	return messages.length === 0 ? Effect.void : Effect.forEach(messages, (message) => Effect.logWarning(message), { discard: true });
+};
+/**
+* The notice for inputs the spec marks deprecated, decided from the request
+* alone — so it is given before dispatch, whatever the transport then does.
+*/
+const noticeDeprecatedInputs = (record, input) => record.mode === "off" || input.operation === null ? Effect.void : Effect.suspend(() => warnings((warn) => inspectDeprecatedInputs({
+	operation: input.operation,
+	query: input.query,
+	body: input.body,
+	headers: input.headers(),
+	table: GENERATED_DEPRECATED_INPUTS,
+	seen: record.seen,
+	warn
+})));
+/**
+* The notice a response carries in its `Deprecation`, `Sunset` and `Link`
+* fields. Given for the response a call ends with, never for one that is
+* discarded and retried or for a hop of a redirect chain.
+*/
+const noticeDeprecatedResponse = (record, input) => record.mode === "off" || input.headers["deprecation"] === void 0 ? Effect.void : Effect.suspend(() => warnings((warn) => inspectDeprecation({
+	response: {
+		headers: new globalThis.Headers(input.headers),
+		url: input.url
+	},
+	method: input.method,
+	path: input.path,
+	operation: input.operation ?? void 0,
+	baseURL: input.baseURL,
+	operations: GENERATED_OPERATIONS,
+	seen: record.seen,
+	warn
+})));
+
+//#endregion
+//#region src/effect/pagination.ts
+/**
+* Cursor pagination as a `Stream`: the items of a standard `items` /
+* `next_cursor` operation, one page requested at a time and only when the
+* stream is pulled that far, so a consumer that stops — or is interrupted —
+* causes no further request.
+*
+* The cursor rules are the ones `./pagination` traverses by, called rather
+* than restated: an absent, null or empty `next_cursor` ends the stream, a
+* cursor the server repeats fails it, and so does a page-number envelope that
+* leaves `next_cursor` out before its last page.
+*/
+/**
+* One page's items and the position after it, or the reason the traversal
+* cannot go on. No request would change that reason, so it is a
+* {@link ConfigurationError} carrying the message `./pagination` throws.
+*/
+const advance = (page, seen) => Result.try({
+	try: () => {
+		const items = page.items;
+		assertPageItems(items);
+		const cursor = standardNextCursor(page);
+		if (isFinalCursor(cursor)) return [items, Option.none()];
+		assertCursorAdvanced(seen, cursor);
+		seen.add(cursor);
+		return [items, Option.some(cursor)];
+	},
+	catch: configurationErrorFrom
+});
+/**
+* The items of every page `fetchPage` returns, in order. `fetchPage` is first
+* called with no cursor, then with each `next_cursor` in turn.
+*/
+const cursorStream = (fetchPage) => Stream.suspend(() => {
+	const seen = /* @__PURE__ */ new Set();
+	return Stream.paginate(void 0, (cursor) => Effect.flatMap(fetchPage(cursor), (page) => Effect.fromResult(advance(page, seen))));
+});
+
+//#endregion
+//#region src/effect/request.ts
+/**
+* The Effect kernel's request path: an operation and its arguments in, an
+* `Effect` of the parsed response out.
+*
+* Everything that decides *what* is sent — the URL, the query string, the
+* body, the header precedence, which credential a request carries — is the
+* compat kernel's own function, called here rather than restated, so the two
+* surfaces cannot drift apart on the wire. This module owns only what differs:
+* the transport is Effect's `HttpClient`, and failures are values.
+*/
+const PLACEHOLDER = /\{[^}]+\}/;
+/** An operation's public chain, dotted: the key its schema is loaded by and the name a `DecodeError` gives it. */
+const operationKey = (operation) => operation?.chain.join(".");
+/**
+* A template's parameters filled in through the compat `path` tag, so encoding
+* and the rejection of `.`/`..` segments are that function's and not a copy.
+*/
+const substitute = (template, params) => {
+	const statics = template.split(PLACEHOLDER);
+	return path(Object.assign(statics, { raw: statics }), ...params);
+};
+const hopHeaders = (prepared, hop) => buildRequestHeaders(prepared.headerConfig, { headers: prepared.callHeaders }, hop.url, hop.bodyHeaders, hop.withdrawn, prepared.scheme, prepared.callerPlaced);
+const prepare = (kernel, call) => {
+	const callHeaders = call.headers();
+	const path = call.path();
+	if (call.options?.timeout !== void 0) validatePositiveInteger("timeout", call.options.timeout);
+	const maxRetries = call.options?.maxRetries ?? kernel.maxRetries;
+	validatePositiveInteger("maxRetries", maxRetries);
+	const decode = call.options?.decode ?? kernel.decode;
+	if (decode) {
+		if (kernel.schemas === void 0) throw new ComposioError(SCHEMAS_MISSING);
+		const operation = operationKey(call.operation);
+		if (operation !== void 0 && kernel.schemas[operation] === void 0) throw new ComposioError(schemaUnavailableMessage(operation));
+	}
+	const { url, query } = buildURL(kernel, {
+		path,
+		query: call.query
+	});
+	const { body, bodyHeaders } = buildBody({ body: call.body });
+	const credentials = revealCredentials(kernel);
+	const shared = {
+		method: call.method,
+		path,
+		label: printableURL(url, call.operation),
+		operation: call.operation,
+		query,
+		headerConfig: {
+			baseURL: kernel.baseURL,
+			credentials,
+			allowedHTTPOrigin: kernel.allowedHTTPOrigin,
+			userAgent: kernel.userAgent,
+			defaultHeaders: kernel.defaultHeaders
+		},
+		callHeaders,
+		scheme: schemeForRequest({ credentials }, call.operation),
+		callerPlaced: callerPlacedCredential([kernel.defaultHeaders, callHeaders]),
+		maxRetries,
+		timeout: call.options?.timeout ?? kernel.timeout,
+		schemas: decode ? kernel.schemas : void 0
+	};
+	const first = {
+		url,
+		method: call.method.toUpperCase(),
+		body,
+		bodyHeaders,
+		withdrawn: false,
+		index: 0
+	};
+	return {
+		...shared,
+		first: {
+			...first,
+			headers: hopHeaders(shared, first)
+		}
+	};
+};
+/**
+* Built from its parts rather than through `HttpClientRequest.make`: the URL
+* already carries its query, serialized by the compat rules, and must reach
+* the transport as that exact string. The body goes out as the same JSON text
+* the compat client hands `fetch`.
+*/
+const toRequest = (hop) => HttpClientRequest.makeWith(hop.method, hop.url, UrlParams.empty, Option.none(), Headers.fromInput(hop.headers), hop.body === void 0 ? HttpBody.empty : HttpBody.raw(hop.body, { contentType: "application/json" }));
+/** A transport cause's own words, following `cause` a few levels down. */
+const describeCause = (cause, depth = 0) => {
+	if (typeof cause === "string") return cause;
+	if (typeof cause !== "object" || cause === null) return void 0;
+	const message = "message" in cause && typeof cause.message === "string" ? cause.message : void 0;
+	const nested = depth < 3 && "cause" in cause ? describeCause(cause.cause, depth + 1) : void 0;
+	if (message === void 0 || message === "") return nested;
+	return nested === void 0 || nested === "" ? message : `${message}: ${nested}`;
+};
+/** The transport's error reduced to text; the error itself holds the request. */
+const describeTransport = (error) => error.reason.description ?? describeCause(error.reason.cause);
+const connectionError = (prepared, error) => new APIConnectionError({
+	message: "Connection error.",
+	method: prepared.first.method,
+	url: prepared.label,
+	reason: error.reason._tag,
+	description: describeTransport(error)
+});
+const timeoutError = (prepared) => new APIConnectionTimeoutError({
+	message: "Request timed out.",
+	method: prepared.first.method,
+	url: prepared.label
+});
+const terminal = (error) => ({
+	error,
+	retryable: false
+});
+const refusedChain = (prepared, reason, message) => terminal(new APIConnectionError({
+	message,
+	method: prepared.first.method,
+	url: prepared.label,
+	reason,
+	description: void 0
+}));
+/** The compat kernel reads a transport failure that says it timed out as a timeout; so does this one. */
+const TIMED_OUT = /timed? ?out/i;
+const transportFailure = (prepared, error) => {
+	const failed = connectionError(prepared, error);
+	return {
+		error: TIMED_OUT.test(failed.description ?? "") ? timeoutError(prepared) : failed,
+		retryable: true
+	};
+};
+const untraced = () => true;
+/**
+* What a span of this request may end on in place of the transport's error.
+*
+* Effect ends a client span on an `HttpClientError` — for a failure below
+* HTTP, and for a 4xx or 5xx answer too, which it marks failed with one it
+* builds itself. That error holds the request, credential headers and all, and
+* a tracer keeps it past the scope the redaction list is extended in. The span
+* gets the error this client would fail with instead, as far as it is known
+* when the span ends: the status class, before the body is read.
+*/
+const spanError = (prepared, error) => {
+	if (!isHttpClientError(error)) return error;
+	const response = error.response;
+	if (response === void 0 || response.status < 400) return transportFailure(prepared, error).error;
+	return apiErrorFromResponse({
+		message: makeAPIErrorMessage(response.status, void 0, void 0),
+		method: prepared.first.method,
+		url: prepared.label,
+		status: response.status,
+		requestId: requestIdOf(response),
+		details: void 0,
+		body: void 0
+	});
+};
+/**
+* The tracer in context, with every span it opens for this request using only
+* the operation template in URL attributes and ending on {@link spanError}.
+* The span is the tracer's own object, changed in place:
+* a tracer recognizes its spans by identity, which a wrapper would not have.
+*/
+const guardingSpans = (prepared) => (tracer) => Tracer.make({
+	span: (options) => {
+		const span = tracer.span(options);
+		const attribute = span.attribute.bind(span);
+		span.attribute = (key, value) => {
+			if (key === "url.full") return attribute(key, prepared.label);
+			if (key === "url.path") return attribute(key, prepared.operation?.path ?? "/<custom>");
+			if (key === "url.query") return;
+			attribute(key, value);
+		};
+		const end = span.end.bind(span);
+		span.end = (endTime, exit) => {
+			end(endTime, Exit.mapError(exit, (error) => spanError(prepared, error)));
+		};
+		return span;
+	},
+	context: tracer.context?.bind(tracer)
+});
+/**
+* One exchange with the transport: a hop in, a response or a failure out.
+*
+* This is the single point every request crosses, and where the client's own
+* configuration is laid over whatever `HttpClient` it was given: the redirect
+* mode a fetch-backed transport dispatches in, the tracing mode, and the
+* credential header names on the redaction list. The application's
+* `RequestInit` is kept except for `redirect`, which is the kernel's — a
+* transport that followed a credentialed request on its own would forward the
+* credential across origins.
+*
+* All of it is one edit of the context, each value read from the context the
+* call runs in.
+*/
+const exchange = (kernel, prepared, hop, redirect) => Effect.suspend(() => kernel.httpClient.execute(toRequest(hop))).pipe(Effect.updateContext((context) => {
+	const overlay = Context.empty().pipe(Context.add(FetchHttpClient.RequestInit, {
+		...Context.getOrUndefined(context, FetchHttpClient.RequestInit),
+		redirect
+	}), Context.add(Headers.CurrentRedactedNames, withCredentialHeaderNames(Context.get(context, Headers.CurrentRedactedNames))), kernel.tracing === "off" ? Context.add(HttpClient.TracerDisabledWhen, untraced) : Context.add(Tracer.Tracer, guardingSpans(prepared)(Context.get(context, Tracer.Tracer))), kernel.tracing === "propagate" ? (self) => self : Context.add(HttpClient.TracerPropagationEnabled, false));
+	return Context.merge(context, overlay);
+}), Effect.catch((error) => error.response !== void 0 && error.reason instanceof StatusCodeError ? Effect.succeed(error.response) : Effect.fail(transportFailure(prepared, error))));
+/**
+* Gives up a response the kernel will not read: one it retries past, or a
+* redirect it follows by hand. Left alone, its request is aborted only when
+* the response is garbage-collected, and the connection stays checked out
+* until then.
+*
+* The body is opened and closed without a read, so its size does not matter.
+* Closing it cancels the underlying stream and ends that request, which is
+* the one request this response came from: the next attempt or hop has its
+* own. It happens on a fiber of its own, since the call does not wait for it
+* and nothing that goes wrong in it is the call's failure. A response with no
+* body, or from a transport that has nothing to cancel, loses nothing.
+*/
+const discard = (response) => Effect.asVoid(Effect.forkDetach(Effect.ignoreCause(Effect.suspend(() => Effect.scoped(Stream.toPull(response.stream)))), { startImmediately: true }));
+/**
+* One attempt: the request, plus however many redirects it takes to land on a
+* response that is not one.
+*
+* The loop is the compat kernel's `dispatchWithRedirects`, hop for hop. The
+* headers of every hop are rebuilt from the URL that hop goes to, so a hop
+* off the configured origin carries no credential; once the chain has changed
+* origin the caller's own credential headers are withdrawn too, for the rest
+* of it. The method and body follow fetch's 301/302/303 rewrite.
+*
+* A first dispatch that carries nothing credential-bearing is handed to the
+* platform to follow, as there: nothing can leak, and it is the only way a
+* browser follows at all. Reading a `Location` needs a transport that returns
+* the 3xx itself — a fetch-backed one in `redirect: 'manual'` does, on Node
+* and on Bun.
+*/
+const followChain = (kernel, prepared, hop) => {
+	const delegated = hop.index === 0 && !carriesCredentials(hop.headers);
+	return Effect.flatMap(exchange(kernel, prepared, hop, delegated ? "follow" : "manual"), (response) => {
+		if (delegated) return Effect.succeed(response);
+		if (response.status === 0) return Effect.fail(refusedChain(prepared, "OpaqueRedirect", OPAQUE_REDIRECT));
+		if (!REDIRECT_STATUSES.has(response.status)) return Effect.succeed(response);
+		const location = response.headers["location"];
+		if (location === void 0) return Effect.succeed(response);
+		const target = resolveHTTPURL(location, hop.url);
+		if (target === null) return Effect.succeed(response);
+		if (hop.index >= 20) return Effect.andThen(discard(response), Effect.fail(refusedChain(prepared, "TooManyRedirects", TOO_MANY_REDIRECTS)));
+		const rewritten = rewriteForRedirect(response.status, hop.method);
+		const next = {
+			url: target.href,
+			method: rewritten ? "GET" : hop.method,
+			body: rewritten ? void 0 : hop.body,
+			bodyHeaders: rewritten ? void 0 : hop.bodyHeaders,
+			withdrawn: hop.withdrawn || target.origin !== new URL(hop.url).origin,
+			index: hop.index + 1
+		};
+		return Effect.andThen(discard(response), Effect.flatMap(Effect.try({
+			try: () => ({
+				...next,
+				headers: hopHeaders(prepared, next)
+			}),
+			catch: (cause) => terminal(configurationErrorFrom(cause))
+		}), (following) => followChain(kernel, prepared, following)));
+	});
+};
+/**
+* One attempt inside its time budget. The whole redirect chain shares the
+* budget, so a chain cannot multiply it by the hop limit; running out
+* interrupts the exchange in flight, which aborts its request.
+*/
+const attempt = (kernel, prepared) => Effect.timeoutOrElse(followChain(kernel, prepared, prepared.first), {
+	duration: prepared.timeout,
+	orElse: () => Effect.fail({
+		error: timeoutError(prepared),
+		retryable: true
+	})
+});
+/**
+* The attempt loop, with the compat kernel's schedule: a connection failure
+* or a timeout is retried, as is a response the server marks retryable
+* (`x-should-retry`) or whose status is 408, 409, 429 or 5xx, whatever the
+* method. The wait is `retry-after-ms`, then `retry-after`, then exponential
+* backoff — that module's `retryDelayMillis`, slept on Effect's clock.
+*
+* A retry re-issues the original request, redirect chain and all.
+*/
+const withRetries = (kernel, prepared, numRetries) => Effect.flatMap(Effect.result(attempt(kernel, prepared)), (result) => {
+	const retriesRemaining = prepared.maxRetries - numRetries;
+	if (Result.isFailure(result)) {
+		const { error, retryable } = result.failure;
+		return retryable && retriesRemaining > 0 ? retryAfter(kernel, prepared, numRetries, retryDelayMillis(numRetries)) : Effect.fail(error);
+	}
+	const response = result.success;
+	if (retriesRemaining > 0 && (response.status < 200 || response.status > 299)) {
+		const headers = new globalThis.Headers(response.headers);
+		if (shouldRetryResponse({
+			status: response.status,
+			headers
+		})) return Effect.andThen(discard(response), retryAfter(kernel, prepared, numRetries, retryDelayMillis(numRetries, headers)));
+	}
+	return Effect.succeed(response);
+});
+/** The next attempt, once the wait before it is over. */
+const retryAfter = (kernel, prepared, numRetries, delayMillis) => Effect.flatMap(Effect.sleep(delayMillis), () => withRetries(kernel, prepared, numRetries + 1));
+/** `APIError.requestId`'s rule: an empty header is "no id", so the envelope still wins. */
+const requestIdOf = (response, envelopeId) => response.headers["x-request-id"] || envelopeId;
+const failForStatus = (prepared, response) => response.text.pipe(Effect.catch((error) => Effect.succeed(describeTransport(error) ?? "")), Effect.flatMap((text) => {
+	const body = safeJSON(text);
+	const details = errorDetails(body);
+	return Effect.fail(apiErrorFromResponse({
+		message: makeAPIErrorMessage(response.status, body, body ? void 0 : text),
+		method: prepared.first.method,
+		url: prepared.label,
+		status: response.status,
+		requestId: requestIdOf(response, details?.request_id),
+		details,
+		body
+	}));
+}));
+const invalidJSON = (prepared, response) => new DecodeError({
+	message: "The response body is not valid JSON.",
+	method: prepared.first.method,
+	url: prepared.label,
+	status: response.status,
+	requestId: requestIdOf(response),
+	operation: operationKey(prepared.operation),
+	issues: [{
+		path: [],
+		kind: "InvalidJSON"
+	}]
+});
+/**
+* The body, once it has passed the operation's schema — when the call asked
+* for that and there is an operation to have one. What comes back is the value
+* that went in, never the schema's output, so nothing the spec does not
+* declare is lost.
+*/
+const validated = (prepared, response, body) => {
+	const operation = operationKey(prepared.operation);
+	if (prepared.schemas === void 0 || operation === void 0) return Effect.succeed(body);
+	return Effect.flatMap(responseIssues(prepared.schemas, operation, body), (issues) => issues.length === 0 ? Effect.succeed(body) : Effect.fail(new DecodeError({
+		message: `The response body does not match the schema of '${operation}'.`,
+		method: prepared.first.method,
+		url: prepared.label,
+		status: response.status,
+		requestId: requestIdOf(response),
+		operation,
+		issues
+	})));
+};
+/**
+* Response parsing by the compat rules: a non-2xx is its status class, a 204
+* is `null`, a JSON media type is parsed (or `undefined` when empty), anything
+* else is text. A 204 has no body to validate; every other success is held to
+* the schema when decoding is on, whatever it was read as.
+*/
+const parse = (prepared, response, headers) => {
+	if (response.status < 200 || response.status > 299) return failForStatus(prepared, response);
+	const kind = classifySuccessBody(response.status, headers["content-type"], headers["content-length"]);
+	if (kind === "null") return Effect.succeed(null);
+	if (kind === "undefined") return validated(prepared, response, void 0);
+	const text = Effect.mapError(response.text, (error) => connectionError(prepared, error));
+	if (kind === "text") return Effect.flatMap(text, (body) => validated(prepared, response, body));
+	return Effect.flatMap(text, (json) => Effect.flatMap(Effect.try({
+		try: () => JSON.parse(json),
+		catch: () => invalidJSON(prepared, response)
+	}), (body) => validated(prepared, response, body)));
+};
+const dispatch = (kernel, call) => Effect.try({
+	try: () => prepare(kernel, call),
+	catch: configurationErrorFrom
+}).pipe(Effect.flatMap((prepared) => {
+	const noticed = call.recovered || prepared.operation?.hasDeprecatedInputs === true ? noticeDeprecatedInputs(kernel.notices, {
+		operation: prepared.operation,
+		query: prepared.query,
+		body: call.body,
+		headers: () => buildHeaders([kernel.defaultHeaders, prepared.callHeaders])
+	}) : void 0;
+	const exchanged = withRetries(kernel, prepared, 0);
+	return Effect.flatMap(noticed === void 0 ? exchanged : Effect.andThen(noticed, exchanged), (response) => {
+		const headers = response.headers;
+		if (kernel.notices.mode === "off" || headers["deprecation"] === void 0) return parse(prepared, response, headers);
+		return Effect.flatMap(noticeDeprecatedResponse(kernel.notices, {
+			method: prepared.method,
+			path: prepared.path,
+			operation: prepared.operation,
+			baseURL: kernel.baseURL,
+			url: response.url,
+			headers
+		}), () => parse(prepared, response, headers));
+	});
+}));
+/**
+* Runs one declared operation. This is what every generated resource method
+* calls: the operation's own descriptor, its arguments, and the caller's
+* per-call options.
+*/
+const executeOperation = (kernel, operation, args, options) => dispatch(kernel, {
+	method: operation.method,
+	path: () => substitute(operation.path, args.path ?? []),
+	query: args.query,
+	body: args.body,
+	headers: () => args.headers === void 0 ? options?.headers : mergeHeaders([args.headers, options?.headers]),
+	operation,
+	recovered: false,
+	options
+});
+/**
+* Runs a request to a path given verbatim — the raw `get`/`post`/`put`/
+* `patch`/`delete` methods. The operation is recovered by matching the path
+* against the table, as the compat client does, so a raw call to a declared
+* path authenticates the way its typed twin would.
+*/
+const executeRaw = (kernel, method, path, options) => dispatch(kernel, {
+	method,
+	path: () => path,
+	query: options?.query,
+	body: options?.body,
+	headers: () => options?.headers,
+	operation: matchOperation(method, path, GENERATED_OPERATIONS),
+	recovered: true,
+	options
+});
+
+//#endregion
+//#region src/effect/generated/resources/tool-router/session/files.ts
+const OP_LIST$15 = generatedOperation("toolRouter.session.files.list");
+const OP_DELETE$7 = generatedOperation("toolRouter.session.files.delete");
+const OP_CREATE_DOWNLOAD_URL = generatedOperation("toolRouter.session.files.createDownloadURL");
+const OP_CREATE_UPLOAD_URL = generatedOperation("toolRouter.session.files.createUploadURL");
+const makeFiles$1 = (kernel) => {
+	const resource = {
+		list: (mountID, params, options) => {
+			const { session_id, ...query } = params;
+			return executeOperation(kernel, OP_LIST$15, {
+				path: [session_id, mountID],
+				query
+			}, options);
+		},
+		listStream: (mountID, params, options) => cursorStream((cursor) => resource.list(mountID, cursor === void 0 ? params : {
+			...params,
+			cursor
+		}, options)),
+		delete: (mountID, params, options) => {
+			const { session_id, ...body } = params;
+			return executeOperation(kernel, OP_DELETE$7, {
+				path: [session_id, mountID],
+				body
+			}, options);
+		},
+		createDownloadURL: (mountID, params, options) => {
+			const { session_id, ...body } = params;
+			return executeOperation(kernel, OP_CREATE_DOWNLOAD_URL, {
+				path: [session_id, mountID],
+				body
+			}, options);
+		},
+		createUploadURL: (mountID, params, options) => {
+			const { session_id, ...body } = params;
+			return executeOperation(kernel, OP_CREATE_UPLOAD_URL, {
+				path: [session_id, mountID],
+				body
+			}, options);
+		}
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/tool-router/session/session.ts
+const OP_CREATE$9 = generatedOperation("toolRouter.session.create");
+const OP_RETRIEVE$14 = generatedOperation("toolRouter.session.retrieve");
+const OP_DELETE$6 = generatedOperation("toolRouter.session.delete");
+const OP_ATTACH = generatedOperation("toolRouter.session.attach");
+const OP_CONFIG_HISTORY = generatedOperation("toolRouter.session.configHistory");
+const OP_EXECUTE$1 = generatedOperation("toolRouter.session.execute");
+const OP_EXECUTE_META = generatedOperation("toolRouter.session.executeMeta");
+const OP_LINK = generatedOperation("toolRouter.session.link");
+const OP_PATCH$1 = generatedOperation("toolRouter.session.patch");
+const OP_PROXY_EXECUTE = generatedOperation("toolRouter.session.proxyExecute");
+const OP_SEARCH = generatedOperation("toolRouter.session.search");
+const OP_TOOLKITS = generatedOperation("toolRouter.session.toolkits");
+const OP_TOOLS = generatedOperation("toolRouter.session.tools");
+const makeSession$1 = (kernel) => {
+	const resource = {
+		files: makeFiles$1(kernel),
+		create: (body, options) => executeOperation(kernel, OP_CREATE$9, { body }, options),
+		retrieve: (sessionID, options) => executeOperation(kernel, OP_RETRIEVE$14, { path: [sessionID] }, options),
+		delete: (sessionID, options) => executeOperation(kernel, OP_DELETE$6, { path: [sessionID] }, options),
+		attach: (sessionID, body = {}, options) => executeOperation(kernel, OP_ATTACH, {
+			path: [sessionID],
+			body
+		}, options),
+		configHistory: (sessionID, query = {}, options) => executeOperation(kernel, OP_CONFIG_HISTORY, {
+			path: [sessionID],
+			query
+		}, options),
+		configHistoryStream: (sessionID, query, options) => cursorStream((cursor) => resource.configHistory(sessionID, cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		execute: (sessionID, body, options) => executeOperation(kernel, OP_EXECUTE$1, {
+			path: [sessionID],
+			body
+		}, options),
+		executeMeta: (sessionID, body, options) => executeOperation(kernel, OP_EXECUTE_META, {
+			path: [sessionID],
+			body
+		}, options),
+		link: (sessionID, body, options) => executeOperation(kernel, OP_LINK, {
+			path: [sessionID],
+			body
+		}, options),
+		patch: (sessionID, body = {}, options) => executeOperation(kernel, OP_PATCH$1, {
+			path: [sessionID],
+			body
+		}, options),
+		proxyExecute: (sessionID, body, options) => executeOperation(kernel, OP_PROXY_EXECUTE, {
+			path: [sessionID],
+			body
+		}, options),
+		search: (sessionID, body, options) => executeOperation(kernel, OP_SEARCH, {
+			path: [sessionID],
+			body
+		}, options),
+		toolkits: (sessionID, query = {}, options) => executeOperation(kernel, OP_TOOLKITS, {
+			path: [sessionID],
+			query
+		}, options),
+		toolkitsStream: (sessionID, query, options) => cursorStream((cursor) => resource.toolkits(sessionID, cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		tools: (sessionID, query = {}, options) => executeOperation(kernel, OP_TOOLS, {
+			path: [sessionID],
+			query
+		}, options),
+		toolsStream: (sessionID, query, options) => cursorStream((cursor) => resource.tools(sessionID, cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options))
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/tool-router/tool-router.ts
+const makeToolRouter = (kernel) => ({ session: makeSession$1(kernel) });
+
+//#endregion
+//#region src/effect/generated/resources/tools.ts
+const OP_RETRIEVE$13 = generatedOperation("tools.retrieve");
+const OP_LIST$14 = generatedOperation("tools.list");
+const OP_EXECUTE = generatedOperation("tools.execute");
+const OP_GET_INPUT = generatedOperation("tools.getInput");
+const OP_PROXY = generatedOperation("tools.proxy");
+const OP_RETRIEVE_ENUM$1 = generatedOperation("tools.retrieveEnum");
+const OP_RETRIEVE_REQUIRED_SCOPES = generatedOperation("tools.retrieveRequiredScopes");
+const makeTools$1 = (kernel) => {
+	const resource = {
+		retrieve: (toolSlug, query = {}, options) => executeOperation(kernel, OP_RETRIEVE$13, {
+			path: [toolSlug],
+			query
+		}, options),
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST$14, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		execute: (toolSlug, params = {}, options) => {
+			const { "x-llm-gateway-headers": xLlmGatewayHeaders, ...body } = params ?? {};
+			return executeOperation(kernel, OP_EXECUTE, {
+				path: [toolSlug],
+				body,
+				headers: { ...xLlmGatewayHeaders != null ? { "x-llm-gateway-headers": xLlmGatewayHeaders } : void 0 }
+			}, options);
+		},
+		getInput: (toolSlug, body, options) => executeOperation(kernel, OP_GET_INPUT, {
+			path: [toolSlug],
+			body
+		}, options),
+		proxy: (body, options) => executeOperation(kernel, OP_PROXY, { body }, options),
+		retrieveEnum: (options) => executeOperation(kernel, OP_RETRIEVE_ENUM$1, {}, options),
+		retrieveRequiredScopes: (body, options) => executeOperation(kernel, OP_RETRIEVE_REQUIRED_SCOPES, { body }, options)
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/files.ts
+const OP_LIST$13 = generatedOperation("files.list");
+const OP_CREATE_PRESIGNED_URL = generatedOperation("files.createPresignedURL");
+const makeFiles = (kernel) => {
+	const resource = {
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST$13, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		createPresignedURL: (body, options) => executeOperation(kernel, OP_CREATE_PRESIGNED_URL, { body }, options)
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/connected-accounts.ts
+const OP_CREATE$8 = generatedOperation("connectedAccounts.create");
+const OP_RETRIEVE$12 = generatedOperation("connectedAccounts.retrieve");
+const OP_LIST$12 = generatedOperation("connectedAccounts.list");
+const OP_DELETE$5 = generatedOperation("connectedAccounts.delete");
+const OP_COMPLETE_AUTH = generatedOperation("connectedAccounts.completeAuth");
+const OP_PATCH = generatedOperation("connectedAccounts.patch");
+const OP_REFRESH = generatedOperation("connectedAccounts.refresh");
+const OP_REVOKE = generatedOperation("connectedAccounts.revoke");
+const OP_UPDATE_STATUS$1 = generatedOperation("connectedAccounts.updateStatus");
+const makeConnectedAccounts = (kernel) => {
+	const resource = {
+		create: (body, options) => executeOperation(kernel, OP_CREATE$8, { body }, options),
+		retrieve: (nanoid, options) => executeOperation(kernel, OP_RETRIEVE$12, { path: [nanoid] }, options),
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST$12, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		delete: (nanoid, query = {}, options) => executeOperation(kernel, OP_DELETE$5, {
+			path: [nanoid],
+			query
+		}, options),
+		completeAuth: (body, options) => executeOperation(kernel, OP_COMPLETE_AUTH, { body }, options),
+		patch: (nanoid, body = {}, options) => executeOperation(kernel, OP_PATCH, {
+			path: [nanoid],
+			body
+		}, options),
+		refresh: (nanoid, params = {}, options) => {
+			const { query_redirect_url, body_redirect_url, ...body } = params ?? {};
+			return executeOperation(kernel, OP_REFRESH, {
+				path: [nanoid],
+				query: { redirect_url: query_redirect_url },
+				body: {
+					...body,
+					redirect_url: body_redirect_url
+				}
+			}, options);
+		},
+		revoke: (nanoid, options) => executeOperation(kernel, OP_REVOKE, { path: [nanoid] }, options),
+		updateStatus: (nanoID, body, options) => executeOperation(kernel, OP_UPDATE_STATUS$1, {
+			path: [nanoID],
+			body
+		}, options)
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/link.ts
+const OP_CREATE$7 = generatedOperation("link.create");
+const makeLink = (kernel) => ({ create: (body, options) => executeOperation(kernel, OP_CREATE$7, { body }, options) });
+
+//#endregion
+//#region src/effect/generated/resources/toolkits.ts
+const OP_RETRIEVE$11 = generatedOperation("toolkits.retrieve");
+const OP_LIST$11 = generatedOperation("toolkits.list");
+const OP_RECOMMEND_SCOPES = generatedOperation("toolkits.recommendScopes");
+const OP_RETRIEVE_CATEGORIES = generatedOperation("toolkits.retrieveCategories");
+const OP_RETRIEVE_CHANGELOG = generatedOperation("toolkits.retrieveChangelog");
+const OP_RETRIEVE_MULTI = generatedOperation("toolkits.retrieveMulti");
+const OP_RETRIEVE_SCOPES_GRANT_CONTEXT = generatedOperation("toolkits.retrieveScopesGrantContext");
+const makeToolkits = (kernel) => {
+	const resource = {
+		retrieve: (slug, query = {}, options) => executeOperation(kernel, OP_RETRIEVE$11, {
+			path: [slug],
+			query
+		}, options),
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST$11, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		recommendScopes: (toolkitSlug, body, options) => executeOperation(kernel, OP_RECOMMEND_SCOPES, {
+			path: [toolkitSlug],
+			body
+		}, options),
+		retrieveCategories: (options) => executeOperation(kernel, OP_RETRIEVE_CATEGORIES, {}, options),
+		retrieveChangelog: (options) => executeOperation(kernel, OP_RETRIEVE_CHANGELOG, {}, options),
+		retrieveMulti: (body = {}, options) => executeOperation(kernel, OP_RETRIEVE_MULTI, { body }, options),
+		retrieveMultiStream: (body, options) => cursorStream((cursor) => resource.retrieveMulti(cursor === void 0 ? body : {
+			...body,
+			cursor
+		}, options)),
+		retrieveScopesGrantContext: (toolkitSlug, query = {}, options) => executeOperation(kernel, OP_RETRIEVE_SCOPES_GRANT_CONTEXT, {
+			path: [toolkitSlug],
+			query
+		}, options)
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/auth-configs.ts
+const OP_CREATE$6 = generatedOperation("authConfigs.create");
+const OP_RETRIEVE$10 = generatedOperation("authConfigs.retrieve");
+const OP_UPDATE$4 = generatedOperation("authConfigs.update");
+const OP_LIST$10 = generatedOperation("authConfigs.list");
+const OP_DELETE$4 = generatedOperation("authConfigs.delete");
+const OP_UPDATE_STATUS = generatedOperation("authConfigs.updateStatus");
+const makeAuthConfigs = (kernel) => {
+	const resource = {
+		create: (body, options) => executeOperation(kernel, OP_CREATE$6, { body }, options),
+		retrieve: (nanoid, options) => executeOperation(kernel, OP_RETRIEVE$10, { path: [nanoid] }, options),
+		update: (nanoid, body, options) => executeOperation(kernel, OP_UPDATE$4, {
+			path: [nanoid],
+			body
+		}, options),
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST$10, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		delete: (nanoid, query = {}, options) => executeOperation(kernel, OP_DELETE$4, {
+			path: [nanoid],
+			query
+		}, options),
+		updateStatus: (status, params, options) => {
+			const { nanoid } = params;
+			return executeOperation(kernel, OP_UPDATE_STATUS, { path: [nanoid, status] }, options);
+		}
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/triggers-types.ts
+const OP_RETRIEVE$9 = generatedOperation("triggersTypes.retrieve");
+const OP_LIST$9 = generatedOperation("triggersTypes.list");
+const OP_RETRIEVE_ENUM = generatedOperation("triggersTypes.retrieveEnum");
+const makeTriggersTypes = (kernel) => {
+	const resource = {
+		retrieve: (slug, query = {}, options) => executeOperation(kernel, OP_RETRIEVE$9, {
+			path: [slug],
+			query
+		}, options),
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST$9, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		retrieveEnum: (options) => executeOperation(kernel, OP_RETRIEVE_ENUM, {}, options)
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/trigger-instances/manage.ts
+const OP_UPDATE$3 = generatedOperation("triggerInstances.manage.update");
+const OP_DELETE$3 = generatedOperation("triggerInstances.manage.delete");
+const makeManage = (kernel) => ({
+	update: (triggerID, body = {}, options) => executeOperation(kernel, OP_UPDATE$3, {
+		path: [triggerID],
+		body
+	}, options),
+	delete: (triggerID, options) => executeOperation(kernel, OP_DELETE$3, { path: [triggerID] }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/trigger-instances/trigger-instances.ts
+const OP_LIST_ACTIVE = generatedOperation("triggerInstances.listActive");
+const OP_UPSERT$1 = generatedOperation("triggerInstances.upsert");
+const makeTriggerInstances = (kernel) => {
+	const resource = {
+		manage: makeManage(kernel),
+		listActive: (query = {}, options) => executeOperation(kernel, OP_LIST_ACTIVE, { query }, options),
+		listActiveStream: (query, options) => cursorStream((cursor) => resource.listActive(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		upsert: (slug, body = {}, options) => executeOperation(kernel, OP_UPSERT$1, {
+			path: [slug],
+			body
+		}, options)
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/mcp/custom.ts
+const OP_CREATE$5 = generatedOperation("mcp.custom.create");
+const makeCustom$1 = (kernel) => ({ create: (body, options) => executeOperation(kernel, OP_CREATE$5, { body }, options) });
+
+//#endregion
+//#region src/effect/generated/resources/mcp/generate.ts
+const OP_URL = generatedOperation("mcp.generate.url");
+const makeGenerate = (kernel) => ({ url: (body, options) => executeOperation(kernel, OP_URL, { body }, options) });
+
+//#endregion
+//#region src/effect/generated/resources/mcp/mcp.ts
+const OP_CREATE$4 = generatedOperation("mcp.create");
+const OP_RETRIEVE$8 = generatedOperation("mcp.retrieve");
+const OP_UPDATE$2 = generatedOperation("mcp.update");
+const OP_LIST$8 = generatedOperation("mcp.list");
+const OP_DELETE$2 = generatedOperation("mcp.delete");
+const OP_CREATE_INSTANCE = generatedOperation("mcp.createInstance");
+const OP_DELETE_INSTANCE = generatedOperation("mcp.deleteInstance");
+const OP_LIST_INSTANCES = generatedOperation("mcp.listInstances");
+const OP_RETRIEVE_APP = generatedOperation("mcp.retrieveApp");
+const makeMcp = (kernel) => ({
+	custom: makeCustom$1(kernel),
+	generate: makeGenerate(kernel),
+	create: (body, options) => executeOperation(kernel, OP_CREATE$4, { body }, options),
+	retrieve: (id, options) => executeOperation(kernel, OP_RETRIEVE$8, { path: [id] }, options),
+	update: (id, body = {}, options) => executeOperation(kernel, OP_UPDATE$2, {
+		path: [id],
+		body
+	}, options),
+	list: (query = {}, options) => executeOperation(kernel, OP_LIST$8, { query }, options),
+	delete: (id, options) => executeOperation(kernel, OP_DELETE$2, { path: [id] }, options),
+	createInstance: (serverID, body, options) => executeOperation(kernel, OP_CREATE_INSTANCE, {
+		path: [serverID],
+		body
+	}, options),
+	deleteInstance: (instanceID, params, options) => {
+		const { serverId } = params;
+		return executeOperation(kernel, OP_DELETE_INSTANCE, { path: [serverId, instanceID] }, options);
+	},
+	listInstances: (serverID, query = {}, options) => executeOperation(kernel, OP_LIST_INSTANCES, {
+		path: [serverID],
+		query
+	}, options),
+	retrieveApp: (appKey, query = {}, options) => executeOperation(kernel, OP_RETRIEVE_APP, {
+		path: [appKey],
+		query
+	}, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/cli/realtime.ts
+const OP_AUTH = generatedOperation("cli.realtime.auth");
+const OP_CREDENTIALS = generatedOperation("cli.realtime.credentials");
+const makeRealtime = (kernel) => ({
+	auth: (body, options) => executeOperation(kernel, OP_AUTH, { body }, options),
+	credentials: (options) => executeOperation(kernel, OP_CREDENTIALS, {}, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/cli/cli.ts
+const OP_CREATE_CODACT_FAILURE = generatedOperation("cli.createCodactFailure");
+const OP_CREATE_SESSION = generatedOperation("cli.createSession");
+const OP_GET_SESSION = generatedOperation("cli.getSession");
+const makeCli = (kernel) => ({
+	realtime: makeRealtime(kernel),
+	createCodactFailure: (params, options) => {
+		const { "x-user-api-key": xUserApiKey, ...body } = params;
+		return executeOperation(kernel, OP_CREATE_CODACT_FAILURE, {
+			body,
+			headers: { ...xUserApiKey != null ? { "x-user-api-key": xUserApiKey } : void 0 }
+		}, options);
+	},
+	createSession: (body = {}, options) => executeOperation(kernel, OP_CREATE_SESSION, { body }, options),
+	getSession: (query, options) => executeOperation(kernel, OP_GET_SESSION, { query }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/logs/triggers.ts
+const OP_RETRIEVE$7 = generatedOperation("logs.triggers.retrieve");
+const OP_LIST$7 = generatedOperation("logs.triggers.list");
+const makeTriggers = (kernel) => ({
+	retrieve: (id, options) => executeOperation(kernel, OP_RETRIEVE$7, { path: [id] }, options),
+	list: (body = {}, options) => executeOperation(kernel, OP_LIST$7, { body }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/logs/tools.ts
+const OP_RETRIEVE$6 = generatedOperation("logs.tools.retrieve");
+const OP_LIST$6 = generatedOperation("logs.tools.list");
+const OP_LIST_FIELDS = generatedOperation("logs.tools.listFields");
+const makeTools = (kernel) => ({
+	retrieve: (id, options) => executeOperation(kernel, OP_RETRIEVE$6, { path: [id] }, options),
+	list: (body, options) => executeOperation(kernel, OP_LIST$6, { body }, options),
+	listFields: (options) => executeOperation(kernel, OP_LIST_FIELDS, {}, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/logs/logs.ts
+const OP_CREATE_TOOL_EXECUTION = generatedOperation("logs.createToolExecution");
+const OP_RETRIEVE_TOOL_EXECUTION = generatedOperation("logs.retrieveToolExecution");
+const makeLogs = (kernel) => ({
+	triggers: makeTriggers(kernel),
+	tools: makeTools(kernel),
+	createToolExecution: (body = {}, options) => executeOperation(kernel, OP_CREATE_TOOL_EXECUTION, { body }, options),
+	retrieveToolExecution: (id, options) => executeOperation(kernel, OP_RETRIEVE_TOOL_EXECUTION, { path: [id] }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/project/usage.ts
+const OP_RETRIEVE$5 = generatedOperation("project.usage.retrieve");
+const OP_RETRIEVE_SUMMARY$1 = generatedOperation("project.usage.retrieveSummary");
+const makeUsage$1 = (kernel) => ({
+	retrieve: (entityType, body = {}, options) => executeOperation(kernel, OP_RETRIEVE$5, {
+		path: [entityType],
+		body
+	}, options),
+	retrieveSummary: (body = {}, options) => executeOperation(kernel, OP_RETRIEVE_SUMMARY$1, { body }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/project/project.ts
+const makeProject$3 = (kernel) => ({ usage: makeUsage$1(kernel) });
+
+//#endregion
+//#region src/effect/generated/resources/webhook-subscriptions.ts
+const OP_CREATE$3 = generatedOperation("webhookSubscriptions.create");
+const OP_RETRIEVE$4 = generatedOperation("webhookSubscriptions.retrieve");
+const OP_UPDATE$1 = generatedOperation("webhookSubscriptions.update");
+const OP_LIST$5 = generatedOperation("webhookSubscriptions.list");
+const OP_DELETE$1 = generatedOperation("webhookSubscriptions.delete");
+const OP_LIST_EVENT_TYPES = generatedOperation("webhookSubscriptions.listEventTypes");
+const OP_ROTATE_SECRET = generatedOperation("webhookSubscriptions.rotateSecret");
+const makeWebhookSubscriptions = (kernel) => {
+	const resource = {
+		create: (body, options) => executeOperation(kernel, OP_CREATE$3, { body }, options),
+		retrieve: (id, options) => executeOperation(kernel, OP_RETRIEVE$4, { path: [id] }, options),
+		update: (id, body = {}, options) => executeOperation(kernel, OP_UPDATE$1, {
+			path: [id],
+			body
+		}, options),
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST$5, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options)),
+		delete: (id, options) => executeOperation(kernel, OP_DELETE$1, { path: [id] }, options),
+		listEventTypes: (options) => executeOperation(kernel, OP_LIST_EVENT_TYPES, {}, options),
+		rotateSecret: (id, options) => executeOperation(kernel, OP_ROTATE_SECRET, { path: [id] }, options)
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resources/webhook-endpoints.ts
+const OP_CREATE$2 = generatedOperation("webhookEndpoints.create");
+const OP_RETRIEVE$3 = generatedOperation("webhookEndpoints.retrieve");
+const OP_UPDATE = generatedOperation("webhookEndpoints.update");
+const OP_LIST$4 = generatedOperation("webhookEndpoints.list");
+const OP_REPLACE = generatedOperation("webhookEndpoints.replace");
+const makeWebhookEndpoints = (kernel) => ({
+	create: (body, options) => executeOperation(kernel, OP_CREATE$2, { body }, options),
+	retrieve: (nanoID, options) => executeOperation(kernel, OP_RETRIEVE$3, { path: [nanoID] }, options),
+	update: (nanoID, body, options) => executeOperation(kernel, OP_UPDATE, {
+		path: [nanoID],
+		body
+	}, options),
+	list: (query = {}, options) => executeOperation(kernel, OP_LIST$4, { query }, options),
+	replace: (nanoID, body, options) => executeOperation(kernel, OP_REPLACE, {
+		path: [nanoID],
+		body
+	}, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/org/owner/project.ts
+const OP_CREATE$1 = generatedOperation("org.owner.project.create");
+const OP_RETRIEVE$2 = generatedOperation("org.owner.project.retrieve");
+const OP_LIST$3 = generatedOperation("org.owner.project.list");
+const OP_DELETE = generatedOperation("org.owner.project.delete");
+const OP_REGENERATE_APIKEY = generatedOperation("org.owner.project.regenerateAPIKey");
+const makeProject$2 = (kernel) => ({
+	create: (body, options) => executeOperation(kernel, OP_CREATE$1, { body }, options),
+	retrieve: (nanoID, options) => executeOperation(kernel, OP_RETRIEVE$2, { path: [nanoID] }, options),
+	list: (query = {}, options) => executeOperation(kernel, OP_LIST$3, { query }, options),
+	delete: (nanoID, query = {}, options) => executeOperation(kernel, OP_DELETE, {
+		path: [nanoID],
+		query
+	}, options),
+	regenerateAPIKey: (nanoID, options) => executeOperation(kernel, OP_REGENERATE_APIKEY, { path: [nanoID] }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/org/owner/owner.ts
+const makeOwner = (kernel) => ({ project: makeProject$2(kernel) });
+
+//#endregion
+//#region src/effect/generated/resources/org/consumer/project.ts
+const OP_RESOLVE = generatedOperation("org.consumer.project.resolve");
+const makeProject$1 = (kernel) => ({ resolve: (params, options) => {
+	const { "x-user-api-key": xUserApiKey, "x-org-id": xOrgId } = params;
+	return executeOperation(kernel, OP_RESOLVE, { headers: {
+		...xUserApiKey != null ? { "x-user-api-key": xUserApiKey } : void 0,
+		...xOrgId != null ? { "x-org-id": xOrgId } : void 0
+	} }, options);
+} });
+
+//#endregion
+//#region src/effect/generated/resources/org/consumer/consumer.ts
+const OP_LIST_CONNECTED_TOOLKITS = generatedOperation("org.consumer.listConnectedToolkits");
+const makeConsumer = (kernel) => ({
+	project: makeProject$1(kernel),
+	listConnectedToolkits: (params, options) => {
+		const { "x-user-api-key": xUserApiKey, "x-org-id": xOrgId, ...query } = params;
+		return executeOperation(kernel, OP_LIST_CONNECTED_TOOLKITS, {
+			query,
+			headers: {
+				...xUserApiKey != null ? { "x-user-api-key": xUserApiKey } : void 0,
+				...xOrgId != null ? { "x-org-id": xOrgId } : void 0
+			}
+		}, options);
+	}
+});
+
+//#endregion
+//#region src/effect/generated/resources/org/project.ts
+const OP_LIST$2 = generatedOperation("org.project.list");
+const makeProject = (kernel) => ({ list: (query = {}, options) => executeOperation(kernel, OP_LIST$2, { query }, options) });
+
+//#endregion
+//#region src/effect/generated/resources/org/usage.ts
+const OP_RETRIEVE$1 = generatedOperation("org.usage.retrieve");
+const OP_RETRIEVE_SUMMARY = generatedOperation("org.usage.retrieveSummary");
+const makeUsage = (kernel) => ({
+	retrieve: (entityType, body = {}, options) => executeOperation(kernel, OP_RETRIEVE$1, {
+		path: [entityType],
+		body
+	}, options),
+	retrieveSummary: (body = {}, options) => executeOperation(kernel, OP_RETRIEVE_SUMMARY, { body }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/org/clanker.ts
+const OP_CREATE_CLAIM = generatedOperation("org.clanker.createClaim");
+const makeClanker = (kernel) => ({ createClaim: (body, options) => executeOperation(kernel, OP_CREATE_CLAIM, { body }, options) });
+
+//#endregion
+//#region src/effect/generated/resources/org/org.ts
+const OP_LIST$1 = generatedOperation("org.list");
+const makeOrg = (kernel) => ({
+	owner: makeOwner(kernel),
+	consumer: makeConsumer(kernel),
+	project: makeProject(kernel),
+	usage: makeUsage(kernel),
+	clanker: makeClanker(kernel),
+	list: (query = {}, options) => executeOperation(kernel, OP_LIST$1, { query }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/auth/session.ts
+const OP_RETRIEVE_INFO = generatedOperation("auth.session.retrieveInfo");
+const makeSession = (kernel) => ({ retrieveInfo: (options) => executeOperation(kernel, OP_RETRIEVE_INFO, {}, options) });
+
+//#endregion
+//#region src/effect/generated/resources/auth/auth.ts
+const makeAuth = (kernel) => ({ session: makeSession(kernel) });
+
+//#endregion
+//#region src/effect/generated/resources/api-key-revocation.ts
+const OP_CREATE = generatedOperation("apiKeyRevocation.create");
+const makeApiKeyRevocation = (kernel) => ({ create: (body, options) => executeOperation(kernel, OP_CREATE, { body }, options) });
+
+//#endregion
+//#region src/effect/generated/resources/custom.ts
+const OP_DELETE_TOOLKIT = generatedOperation("custom.deleteToolkit");
+const OP_SYNC = generatedOperation("custom.sync");
+const OP_UPSERT = generatedOperation("custom.upsert");
+const makeCustom = (kernel) => ({
+	deleteToolkit: (slug, query = {}, options) => executeOperation(kernel, OP_DELETE_TOOLKIT, {
+		path: [slug],
+		query
+	}, options),
+	sync: (body, options) => executeOperation(kernel, OP_SYNC, { body }, options),
+	upsert: (body, options) => executeOperation(kernel, OP_UPSERT, { body }, options)
+});
+
+//#endregion
+//#region src/effect/generated/resources/keyring.ts
+const OP_LIST_TRANSFER_KEYS = generatedOperation("keyring.listTransferKeys");
+const makeKeyring = (kernel) => ({ listTransferKeys: (options) => executeOperation(kernel, OP_LIST_TRANSFER_KEYS, {}, options) });
+
+//#endregion
+//#region src/effect/generated/resources/session-configs.ts
+const OP_RETRIEVE = generatedOperation("sessionConfigs.retrieve");
+const OP_LIST = generatedOperation("sessionConfigs.list");
+const makeSessionConfigs = (kernel) => {
+	const resource = {
+		retrieve: (sessionConfigID, options) => executeOperation(kernel, OP_RETRIEVE, { path: [sessionConfigID] }, options),
+		list: (query = {}, options) => executeOperation(kernel, OP_LIST, { query }, options),
+		listStream: (query, options) => cursorStream((cursor) => resource.list(cursor === void 0 ? query : {
+			...query,
+			cursor
+		}, options))
+	};
+	return resource;
+};
+
+//#endregion
+//#region src/effect/generated/resource-wiring.ts
+const createClientResources = (kernel) => ({
+	toolRouter: makeToolRouter(kernel),
+	tools: makeTools$1(kernel),
+	files: makeFiles(kernel),
+	connectedAccounts: makeConnectedAccounts(kernel),
+	link: makeLink(kernel),
+	toolkits: makeToolkits(kernel),
+	authConfigs: makeAuthConfigs(kernel),
+	triggersTypes: makeTriggersTypes(kernel),
+	triggerInstances: makeTriggerInstances(kernel),
+	mcp: makeMcp(kernel),
+	cli: makeCli(kernel),
+	logs: makeLogs(kernel),
+	project: makeProject$3(kernel),
+	webhookSubscriptions: makeWebhookSubscriptions(kernel),
+	webhookEndpoints: makeWebhookEndpoints(kernel),
+	org: makeOrg(kernel),
+	auth: makeAuth(kernel),
+	apiKeyRevocation: makeApiKeyRevocation(kernel),
+	custom: makeCustom(kernel),
+	keyring: makeKeyring(kernel),
+	sessionConfigs: makeSessionConfigs(kernel)
+});
+
+//#endregion
+//#region src/effect/client.ts
+/**
+* The Effect client: a `Context.Service`, layers that build it from the
+* `HttpClient` in context (or bring a fetch-backed one), and a plain
+* constructor for callers who already hold one.
+*
+* Options are fixed at construction. Nothing here reads the environment except
+* {@link layerConfig}, which reads the `COMPOSIO_*` settings through Effect's
+* `Config` — so the `ConfigProvider` in context decides where they come from.
+*/
+var ComposioClient = class extends Context.Service()("@composio/client/effect/ComposioClient") {};
+const DEFAULT_BASE_URL = "https://backend.composio.dev";
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_TIMEOUT = 6e4;
+const hold = (credential) => {
+	if (credential === null || credential === void 0) return null;
+	return Redacted.isRedacted(credential) ? credential : Redacted.make(credential);
+};
+const resolveKernel = (options, httpClient) => {
+	const baseURL = options.baseURL || DEFAULT_BASE_URL;
+	if (options.decode === true && options.schemas === void 0) return Result.fail(new ConfigurationError({ message: SCHEMAS_MISSING }));
+	const kernel = {
+		httpClient,
+		baseURL,
+		apiKey: hold(options.apiKey),
+		userApiKey: hold(options.userApiKey),
+		orgApiKey: hold(options.orgApiKey),
+		allowedHTTPOrigin: options.allowInsecureHTTP ? parseHTTPURL(baseURL)?.origin ?? null : null,
+		userAgent: `Composio/JS ${VERSION}`,
+		defaultHeaders: options.defaultHeaders,
+		defaultQuery: options.defaultQuery,
+		maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+		timeout: options.timeout ?? DEFAULT_TIMEOUT,
+		tracing: options.tracing ?? "off",
+		decode: options.decode ?? false,
+		schemas: options.schemas,
+		notices: makeNoticeRecord(options.deprecationNotices)
+	};
+	const unsendable = unsendableCredential(kernel);
+	if (unsendable !== void 0) return Result.fail(new ConfigurationError({ message: `The \`${unsendable}\` option cannot be sent as a header: it contains a line break, a NUL or a character outside Latin-1.` }));
+	return Result.try({
+		try: () => {
+			assertCredentialTransport(baseURL, revealCredentials(kernel), kernel.allowedHTTPOrigin);
+			return kernel;
+		},
+		catch: configurationErrorFrom
+	});
+};
+const fromKernel = (kernel) => ({
+	...createClientResources(kernel),
+	get: (path, options) => executeRaw(kernel, "get", path, options),
+	post: (path, options) => executeRaw(kernel, "post", path, options),
+	put: (path, options) => executeRaw(kernel, "put", path, options),
+	patch: (path, options) => executeRaw(kernel, "patch", path, options),
+	delete: (path, options) => executeRaw(kernel, "delete", path, options)
+});
+/**
+* The kernel a client dispatches through. Internal: the generated resources
+* are built over it, and it is not part of the entry's exports.
+*
+* @throws {ConfigurationError} when a credentialed origin is not HTTPS, a
+*   credential cannot be sent as a header, or the client is to decode and was
+*   given no schemas.
+*/
+const makeKernel = (options, httpClient) => Result.getOrThrow(resolveKernel(options, httpClient));
+/**
+* Builds a client synchronously from an `HttpClient` the caller already holds.
+* Reads no environment variable.
+*
+* @throws {ConfigurationError} when a credentialed origin is not HTTPS, a
+*   credential cannot be sent as a header, or the client is to decode and was
+*   given no schemas.
+*/
+const make = (options, httpClient) => fromKernel(makeKernel(options, httpClient));
+/**
+* Provides the client from explicit options and the `HttpClient` in context.
+* Reads no environment variable.
+*/
+const layer = (options = {}) => Layer.effect(ComposioClient, Effect.flatMap(HttpClient.HttpClient, (httpClient) => Effect.map(Effect.fromResult(resolveKernel(options, httpClient)), fromKernel)));
+/**
+* {@link layer} over a fetch-backed `HttpClient`, for an application that has
+* no transport of its own to supply. `fetch` is the platform's, or whatever
+* the `FetchHttpClient.Fetch` reference in context names.
+*/
+const layerFetch = (options = {}) => Layer.provide(layer(options), FetchHttpClient.layer);
+/** A setting as the compat client reads one: trimmed, and absent when empty. */
+const setting = (name) => Config.map(Config.option(Config.String(name)), (value) => Option.getOrUndefined(Option.filter(Option.map(value, (text) => text.trim()), (text) => text !== "")));
+const settings = Config.all({
+	apiKey: setting("COMPOSIO_API_KEY"),
+	userApiKey: setting("COMPOSIO_USER_API_KEY"),
+	orgApiKey: setting("COMPOSIO_ORG_API_KEY"),
+	baseURL: setting("COMPOSIO_BASE_URL"),
+	allowInsecureHTTP: setting("COMPOSIO_ALLOW_INSECURE_HTTP")
+});
+/**
+* Provides the client from the `COMPOSIO_*` settings — `COMPOSIO_API_KEY`,
+* `COMPOSIO_USER_API_KEY`, `COMPOSIO_ORG_API_KEY`, `COMPOSIO_BASE_URL` and
+* `COMPOSIO_ALLOW_INSECURE_HTTP=1` — read through the `ConfigProvider` in
+* context, which is the process environment unless the application says
+* otherwise. An option given here wins over its setting; `null` for a
+* credential means "none", whatever is configured.
+*/
+const layerConfig = (options = {}) => Layer.effect(ComposioClient, Effect.gen(function* () {
+	const httpClient = yield* HttpClient.HttpClient;
+	const env = yield* Effect.mapError(settings, () => new ConfigurationError({ message: "The COMPOSIO_* configuration could not be read." }));
+	const kernel = yield* Effect.fromResult(resolveKernel({
+		...options,
+		apiKey: options.apiKey !== void 0 ? options.apiKey : env.apiKey,
+		userApiKey: options.userApiKey !== void 0 ? options.userApiKey : env.userApiKey,
+		orgApiKey: options.orgApiKey !== void 0 ? options.orgApiKey : env.orgApiKey,
+		baseURL: options.baseURL ?? env.baseURL,
+		allowInsecureHTTP: options.allowInsecureHTTP ?? env.allowInsecureHTTP === "1"
+	}, httpClient));
+	return fromKernel(kernel);
+}));
+
+//#endregion
+export { APIConnectionError, APIConnectionTimeoutError, APIError, AuthenticationError, BadRequestError, ComposioClient, ConfigurationError, ConflictError, DecodeError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, UnprocessableEntityError, VERSION, isAPIError, isComposioError, layer, layerConfig, layerFetch, make };