@open-connector/sdk 1.0.2

package/dist/index-BXEKBblV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BXEKBblV.d.ts","names":[],"sources":["../../authorization/src/index.ts","../../api-contracts/src/lib/native/index.ts","../src/client.ts","../src/connect.ts"],"mappings":"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"}

package/dist/index.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src = require("./src-19LKPmdg.cjs");
+exports.connectOAuth = require_src.connectOAuth;
+exports.createClient = require_src.createClient;
+exports.waitForConnection = require_src.waitForConnection;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { c as ClientOptions, i as WaitOptions, l as OpenConnectorClient, n as ConnectOAuthOptions, o as connectOAuth, r as ConnectResult, s as waitForConnection, u as createClient } from "./index-96n68fp1.cjs";
+export { type ClientOptions, type ConnectOAuthOptions, type ConnectResult, type OpenConnectorClient, type WaitOptions, connectOAuth, createClient, waitForConnection };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { c as ClientOptions, i as WaitOptions, l as OpenConnectorClient, n as ConnectOAuthOptions, o as connectOAuth, r as ConnectResult, s as waitForConnection, u as createClient } from "./index-BXEKBblV.js";
+export { type ClientOptions, type ConnectOAuthOptions, type ConnectResult, type OpenConnectorClient, type WaitOptions, connectOAuth, createClient, waitForConnection };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { i as createClient, n as connectOAuth, r as waitForConnection } from "./src-CvNjrj1s.js";
+export { connectOAuth, createClient, waitForConnection };

package/dist/src-19LKPmdg.cjs

@@ -0,0 +1,118 @@
+let _orpc_client = require("@orpc/client");
+let _orpc_client_fetch = require("@orpc/client/fetch");
+let evlog = require("evlog");
+//#region src/client.ts
+/** The native RPC handler is mounted at `/api/v1` (the console appRouter owns
+*  `/api/v1/rpc`). Trim any trailing slash so we never produce `//api/v1`. */
+function resolveRpcUrl(baseUrl) {
+	return `${baseUrl.replace(/\/+$/, "")}/api/v1`;
+}
+/** Create a typed Open Connector client bound to a Project key or Human OAuth capability. */
+function createClient(opts) {
+	const link = new _orpc_client_fetch.RPCLink({
+		url: resolveRpcUrl(opts.baseUrl),
+		headers: "apiKey" in opts && opts.apiKey ? { "x-api-key": opts.apiKey } : async () => ({
+			authorization: `Bearer ${typeof opts.accessToken === "function" ? await opts.accessToken() : opts.accessToken}`,
+			"x-organization-id": opts.organizationId,
+			"x-project-id": opts.projectId
+		}),
+		...opts.fetch ? { fetch: opts.fetch } : {}
+	});
+	return (0, _orpc_client.createORPCClient)(link);
+}
+//#endregion
+//#region src/connect.ts
+/** Statuses that mean "keep waiting" — the OAuth round-trip is still in flight. */
+const PENDING_STATUSES = /* @__PURE__ */ new Set(["pending", "initiated"]);
+/** A connect/wait failure: code `connect.timeout` | `connect.failed`. The last connection status is in the message. */
+function connectError(reason, message) {
+	return (0, evlog.createError)({
+		code: reason === "timeout" ? "connect.timeout" : "connect.failed",
+		message,
+		status: reason === "timeout" ? 408 : 502,
+		why: reason === "timeout" ? "The connection did not reach `active` before the timeout" : "The connection reached a terminal non-active status",
+		fix: reason === "timeout" ? "Increase timeoutMs, or have the user finish provider authorization or credential entry" : "Create a new connect link or re-initiate the connection"
+	});
+}
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+* Poll `getConnection` until it reaches `active`, mirroring Composio's
+* `waitForConnection`. Resolves with the active connection id; throws an
+* `EvlogError` (code `connect.failed` | `connect.timeout`) on a terminal-failure status or timeout.
+*/
+async function waitForConnection(client, connectionId, opts = {}) {
+	const timeoutMs = opts.timeoutMs ?? 12e4;
+	const intervalMs = opts.intervalMs ?? 2e3;
+	const now = opts.now ?? Date.now;
+	const sleep = opts.sleep ?? defaultSleep;
+	const deadline = now() + timeoutMs;
+	for (;;) {
+		const conn = await client.getConnection({ connectionId });
+		if (conn.status === "active") return {
+			connectionId,
+			status: "active"
+		};
+		if (!PENDING_STATUSES.has(conn.status)) throw connectError("failed", `connection ${connectionId} is ${conn.status}`);
+		if (now() >= deadline) throw connectError("timeout", `timed out after ${timeoutMs}ms waiting for connection ${connectionId} (last status: ${conn.status})`);
+		await sleep(intervalMs);
+	}
+}
+/**
+* Begin an OAuth2 connection and (by default) wait for it to become active.
+* The caller is responsible for getting the user to the `redirectUrl` (the CLI
+* opens it / prints it). With `waitForActive: false` it returns immediately
+* after `initiate`.
+*/
+async function connectOAuth(client, opts) {
+	const init = await client.initiate({
+		slug: opts.slug,
+		authConfigId: opts.authConfigId,
+		authMethodId: opts.authMethodId,
+		userId: opts.userId,
+		scopes: opts.scopes
+	});
+	if (init.redirectUrl) opts.onRedirect?.(init.redirectUrl);
+	if (opts.waitForActive === false) return {
+		connectionId: init.connectionId,
+		status: "pending",
+		redirectUrl: init.redirectUrl
+	};
+	return {
+		connectionId: (await waitForConnection(client, init.connectionId, opts)).connectionId,
+		status: "active",
+		redirectUrl: init.redirectUrl
+	};
+}
+//#endregion
+Object.defineProperty(exports, "connectError", {
+	enumerable: true,
+	get: function() {
+		return connectError;
+	}
+});
+Object.defineProperty(exports, "connectOAuth", {
+	enumerable: true,
+	get: function() {
+		return connectOAuth;
+	}
+});
+Object.defineProperty(exports, "createClient", {
+	enumerable: true,
+	get: function() {
+		return createClient;
+	}
+});
+Object.defineProperty(exports, "resolveRpcUrl", {
+	enumerable: true,
+	get: function() {
+		return resolveRpcUrl;
+	}
+});
+Object.defineProperty(exports, "waitForConnection", {
+	enumerable: true,
+	get: function() {
+		return waitForConnection;
+	}
+});
+
+//# sourceMappingURL=src-19LKPmdg.cjs.map

package/dist/src-19LKPmdg.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"src-19LKPmdg.cjs","names":["RPCLink","createORPCClient","createError"],"sources":["../src/client.ts","../src/connect.ts"],"sourcesContent":["import { createORPCClient } from \"@orpc/client\";\nimport { RPCLink } from \"@orpc/client/fetch\";\nimport type { NativeContract } from \"@open-connector/api-contracts\";\nimport type { ContractRouterClient } from \"@orpc/contract\";\n\n/**\n * The first-party Open Connector SDK client — a fully-typed `@orpc/client`\n * over the native oRPC contract (`/api/v1`). The published declarations bundle\n * this contract so consumers do not need any private workspace packages.\n */\nexport type OpenConnectorClient = ContractRouterClient<NativeContract>;\n\ninterface BaseClientOptions {\n  /** Base URL of the Open Connector server, e.g. `http://localhost:3000`. */\n  baseUrl: string;\n  /** Optional fetch override (used by tests to route into an in-process app). */\n  fetch?: typeof fetch;\n}\n\nexport type ClientOptions = BaseClientOptions &\n  (\n    | {\n        /** Project (agent) API key — sent as the `x-api-key` header. */\n        apiKey: string;\n        accessToken?: never;\n        organizationId?: never;\n        projectId?: never;\n      }\n    | {\n        apiKey?: never;\n        /** Human OAuth token, or an async provider that refreshes it before each request. */\n        accessToken: string | (() => string | Promise<string>);\n        /** Explicit live Organization selected by the Human client. */\n        organizationId: string;\n        /** Explicit live Project selected by the Human client. */\n        projectId: string;\n      }\n  );\n\n/** The native RPC handler is mounted at `/api/v1` (the console appRouter owns\n *  `/api/v1/rpc`). Trim any trailing slash so we never produce `//api/v1`. */\nexport function resolveRpcUrl(baseUrl: string): string {\n  return `${baseUrl.replace(/\\/+$/, \"\")}/api/v1`;\n}\n\n/** Create a typed Open Connector client bound to a Project key or Human OAuth capability. */\nexport function createClient(opts: ClientOptions): OpenConnectorClient {\n  const link = new RPCLink({\n    url: resolveRpcUrl(opts.baseUrl),\n    headers:\n      \"apiKey\" in opts && opts.apiKey\n        ? { \"x-api-key\": opts.apiKey }\n        : async () => ({\n            authorization: `Bearer ${\n              typeof opts.accessToken === \"function\" ? await opts.accessToken() : opts.accessToken\n            }`,\n            \"x-organization-id\": opts.organizationId,\n            \"x-project-id\": opts.projectId,\n          }),\n    ...(opts.fetch ? { fetch: opts.fetch } : {}),\n  });\n  return createORPCClient(link);\n}\n","import { createError, type EvlogError } from \"evlog\";\n\nimport type { OpenConnectorClient } from \"./client\";\n\n/** Statuses that mean \"keep waiting\" — the OAuth round-trip is still in flight. */\nconst PENDING_STATUSES = new Set([\"pending\", \"initiated\"]);\n\nexport type ConnectErrorReason = \"timeout\" | \"failed\";\n\n/** A connect/wait failure: code `connect.timeout` | `connect.failed`. The last connection status is in the message. */\nexport function connectError(reason: ConnectErrorReason, message: string): EvlogError {\n  return createError({\n    code: reason === \"timeout\" ? \"connect.timeout\" : \"connect.failed\",\n    message,\n    status: reason === \"timeout\" ? 408 : 502,\n    why:\n      reason === \"timeout\"\n        ? \"The connection did not reach `active` before the timeout\"\n        : \"The connection reached a terminal non-active status\",\n    fix:\n      reason === \"timeout\"\n        ? \"Increase timeoutMs, or have the user finish provider authorization or credential entry\"\n        : \"Create a new connect link or re-initiate the connection\",\n  });\n}\n\nexport interface WaitOptions {\n  /** Give up after this many ms (default 120_000). */\n  timeoutMs?: number;\n  /** Poll cadence in ms (default 2_000). */\n  intervalMs?: number;\n  /** Injectable clock + sleep so the loop is deterministic under test. */\n  now?: () => number;\n  sleep?: (ms: number) => Promise<void>;\n}\n\n// Only the two methods the wait loop calls — lets callers (and tests) pass a\n// narrower object than the full client.\ntype ConnectClient = Pick<OpenConnectorClient, \"initiate\" | \"getConnection\">;\n\nconst defaultSleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));\n\n/**\n * Poll `getConnection` until it reaches `active`, mirroring Composio's\n * `waitForConnection`. Resolves with the active connection id; throws an\n * `EvlogError` (code `connect.failed` | `connect.timeout`) on a terminal-failure status or timeout.\n */\nexport async function waitForConnection(\n  client: ConnectClient,\n  connectionId: string,\n  opts: WaitOptions = {},\n): Promise<{ connectionId: string; status: \"active\" }> {\n  const timeoutMs = opts.timeoutMs ?? 120_000;\n  const intervalMs = opts.intervalMs ?? 2_000;\n  const now = opts.now ?? Date.now;\n  const sleep = opts.sleep ?? defaultSleep;\n  const deadline = now() + timeoutMs;\n\n  for (;;) {\n    const conn = await client.getConnection({ connectionId });\n    if (conn.status === \"active\") return { connectionId, status: \"active\" };\n    if (!PENDING_STATUSES.has(conn.status)) {\n      throw connectError(\"failed\", `connection ${connectionId} is ${conn.status}`);\n    }\n    if (now() >= deadline) {\n      throw connectError(\n        \"timeout\",\n        `timed out after ${timeoutMs}ms waiting for connection ${connectionId} (last status: ${conn.status})`,\n      );\n    }\n    await sleep(intervalMs);\n  }\n}\n\nexport interface ConnectOAuthOptions extends WaitOptions {\n  slug: string;\n  authConfigId?: string;\n  authMethodId?: string;\n  /** Project-local connector business partition; independent from the authenticated Human. */\n  userId: string;\n  scopes?: string[];\n  /** Called with the provider authorize URL the user must visit (if any). */\n  onRedirect?: (url: string) => void;\n  /** When true (default), poll until the connection is active before resolving. */\n  waitForActive?: boolean;\n}\n\nexport interface ConnectResult {\n  connectionId: string;\n  status: \"pending\" | \"active\";\n  redirectUrl?: string;\n}\n\n/**\n * Begin an OAuth2 connection and (by default) wait for it to become active.\n * The caller is responsible for getting the user to the `redirectUrl` (the CLI\n * opens it / prints it). With `waitForActive: false` it returns immediately\n * after `initiate`.\n */\nexport async function connectOAuth(\n  client: ConnectClient,\n  opts: ConnectOAuthOptions,\n): Promise<ConnectResult> {\n  const init = await client.initiate({\n    slug: opts.slug,\n    authConfigId: opts.authConfigId,\n    authMethodId: opts.authMethodId,\n    userId: opts.userId,\n    scopes: opts.scopes,\n  });\n  if (init.redirectUrl) opts.onRedirect?.(init.redirectUrl);\n\n  if (opts.waitForActive === false) {\n    return { connectionId: init.connectionId, status: \"pending\", redirectUrl: init.redirectUrl };\n  }\n  const done = await waitForConnection(client, init.connectionId, opts);\n  return { connectionId: done.connectionId, status: \"active\", redirectUrl: init.redirectUrl };\n}\n"],"mappings":";;;;;;AAyCA,SAAgB,cAAc,SAAyB;CACrD,OAAO,GAAG,QAAQ,QAAQ,QAAQ,EAAE,EAAE;AACxC;;AAGA,SAAgB,aAAa,MAA0C;CACrE,MAAM,OAAO,IAAIA,mBAAAA,QAAQ;EACvB,KAAK,cAAc,KAAK,OAAO;EAC/B,SACE,YAAY,QAAQ,KAAK,SACrB,EAAE,aAAa,KAAK,OAAO,IAC3B,aAAa;GACX,eAAe,UACb,OAAO,KAAK,gBAAgB,aAAa,MAAM,KAAK,YAAY,IAAI,KAAK;GAE3E,qBAAqB,KAAK;GAC1B,gBAAgB,KAAK;EACvB;EACN,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;CAC5C,CAAC;CACD,QAAA,GAAOC,aAAAA,iBAAAA,CAAiB,IAAI;AAC9B;;;;ACzDA,MAAM,mCAAmB,IAAI,IAAI,CAAC,WAAW,WAAW,CAAC;;AAKzD,SAAgB,aAAa,QAA4B,SAA6B;CACpF,QAAA,GAAOC,MAAAA,YAAAA,CAAY;EACjB,MAAM,WAAW,YAAY,oBAAoB;EACjD;EACA,QAAQ,WAAW,YAAY,MAAM;EACrC,KACE,WAAW,YACP,6DACA;EACN,KACE,WAAW,YACP,2FACA;CACR,CAAC;AACH;AAgBA,MAAM,gBAAgB,OAAe,IAAI,SAAe,MAAM,WAAW,GAAG,EAAE,CAAC;;;;;;AAO/E,eAAsB,kBACpB,QACA,cACA,OAAoB,CAAC,GACgC;CACrD,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,aAAa,KAAK,cAAc;CACtC,MAAM,MAAM,KAAK,OAAO,KAAK;CAC7B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,IAAI,IAAI;CAEzB,SAAS;EACP,MAAM,OAAO,MAAM,OAAO,cAAc,EAAE,aAAa,CAAC;EACxD,IAAI,KAAK,WAAW,UAAU,OAAO;GAAE;GAAc,QAAQ;EAAS;EACtE,IAAI,CAAC,iBAAiB,IAAI,KAAK,MAAM,GACnC,MAAM,aAAa,UAAU,cAAc,aAAa,MAAM,KAAK,QAAQ;EAE7E,IAAI,IAAI,KAAK,UACX,MAAM,aACJ,WACA,mBAAmB,UAAU,4BAA4B,aAAa,iBAAiB,KAAK,OAAO,EACrG;EAEF,MAAM,MAAM,UAAU;CACxB;AACF;;;;;;;AA2BA,eAAsB,aACpB,QACA,MACwB;CACxB,MAAM,OAAO,MAAM,OAAO,SAAS;EACjC,MAAM,KAAK;EACX,cAAc,KAAK;EACnB,cAAc,KAAK;EACnB,QAAQ,KAAK;EACb,QAAQ,KAAK;CACf,CAAC;CACD,IAAI,KAAK,aAAa,KAAK,aAAa,KAAK,WAAW;CAExD,IAAI,KAAK,kBAAkB,OACzB,OAAO;EAAE,cAAc,KAAK;EAAc,QAAQ;EAAW,aAAa,KAAK;CAAY;CAG7F,OAAO;EAAE,eAAc,MADJ,kBAAkB,QAAQ,KAAK,cAAc,IAAI,EAAA,CACxC;EAAc,QAAQ;EAAU,aAAa,KAAK;CAAY;AAC5F"}

package/dist/src-CvNjrj1s.js

@@ -0,0 +1,89 @@
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { createError } from "evlog";
+//#region src/client.ts
+/** The native RPC handler is mounted at `/api/v1` (the console appRouter owns
+*  `/api/v1/rpc`). Trim any trailing slash so we never produce `//api/v1`. */
+function resolveRpcUrl(baseUrl) {
+	return `${baseUrl.replace(/\/+$/, "")}/api/v1`;
+}
+/** Create a typed Open Connector client bound to a Project key or Human OAuth capability. */
+function createClient(opts) {
+	const link = new RPCLink({
+		url: resolveRpcUrl(opts.baseUrl),
+		headers: "apiKey" in opts && opts.apiKey ? { "x-api-key": opts.apiKey } : async () => ({
+			authorization: `Bearer ${typeof opts.accessToken === "function" ? await opts.accessToken() : opts.accessToken}`,
+			"x-organization-id": opts.organizationId,
+			"x-project-id": opts.projectId
+		}),
+		...opts.fetch ? { fetch: opts.fetch } : {}
+	});
+	return createORPCClient(link);
+}
+//#endregion
+//#region src/connect.ts
+/** Statuses that mean "keep waiting" — the OAuth round-trip is still in flight. */
+const PENDING_STATUSES = /* @__PURE__ */ new Set(["pending", "initiated"]);
+/** A connect/wait failure: code `connect.timeout` | `connect.failed`. The last connection status is in the message. */
+function connectError(reason, message) {
+	return createError({
+		code: reason === "timeout" ? "connect.timeout" : "connect.failed",
+		message,
+		status: reason === "timeout" ? 408 : 502,
+		why: reason === "timeout" ? "The connection did not reach `active` before the timeout" : "The connection reached a terminal non-active status",
+		fix: reason === "timeout" ? "Increase timeoutMs, or have the user finish provider authorization or credential entry" : "Create a new connect link or re-initiate the connection"
+	});
+}
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+* Poll `getConnection` until it reaches `active`, mirroring Composio's
+* `waitForConnection`. Resolves with the active connection id; throws an
+* `EvlogError` (code `connect.failed` | `connect.timeout`) on a terminal-failure status or timeout.
+*/
+async function waitForConnection(client, connectionId, opts = {}) {
+	const timeoutMs = opts.timeoutMs ?? 12e4;
+	const intervalMs = opts.intervalMs ?? 2e3;
+	const now = opts.now ?? Date.now;
+	const sleep = opts.sleep ?? defaultSleep;
+	const deadline = now() + timeoutMs;
+	for (;;) {
+		const conn = await client.getConnection({ connectionId });
+		if (conn.status === "active") return {
+			connectionId,
+			status: "active"
+		};
+		if (!PENDING_STATUSES.has(conn.status)) throw connectError("failed", `connection ${connectionId} is ${conn.status}`);
+		if (now() >= deadline) throw connectError("timeout", `timed out after ${timeoutMs}ms waiting for connection ${connectionId} (last status: ${conn.status})`);
+		await sleep(intervalMs);
+	}
+}
+/**
+* Begin an OAuth2 connection and (by default) wait for it to become active.
+* The caller is responsible for getting the user to the `redirectUrl` (the CLI
+* opens it / prints it). With `waitForActive: false` it returns immediately
+* after `initiate`.
+*/
+async function connectOAuth(client, opts) {
+	const init = await client.initiate({
+		slug: opts.slug,
+		authConfigId: opts.authConfigId,
+		authMethodId: opts.authMethodId,
+		userId: opts.userId,
+		scopes: opts.scopes
+	});
+	if (init.redirectUrl) opts.onRedirect?.(init.redirectUrl);
+	if (opts.waitForActive === false) return {
+		connectionId: init.connectionId,
+		status: "pending",
+		redirectUrl: init.redirectUrl
+	};
+	return {
+		connectionId: (await waitForConnection(client, init.connectionId, opts)).connectionId,
+		status: "active",
+		redirectUrl: init.redirectUrl
+	};
+}
+//#endregion
+export { resolveRpcUrl as a, createClient as i, connectOAuth as n, waitForConnection as r, connectError as t };
+
+//# sourceMappingURL=src-CvNjrj1s.js.map

package/dist/src-CvNjrj1s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"src-CvNjrj1s.js","names":[],"sources":["../src/client.ts","../src/connect.ts"],"sourcesContent":["import { createORPCClient } from \"@orpc/client\";\nimport { RPCLink } from \"@orpc/client/fetch\";\nimport type { NativeContract } from \"@open-connector/api-contracts\";\nimport type { ContractRouterClient } from \"@orpc/contract\";\n\n/**\n * The first-party Open Connector SDK client — a fully-typed `@orpc/client`\n * over the native oRPC contract (`/api/v1`). The published declarations bundle\n * this contract so consumers do not need any private workspace packages.\n */\nexport type OpenConnectorClient = ContractRouterClient<NativeContract>;\n\ninterface BaseClientOptions {\n  /** Base URL of the Open Connector server, e.g. `http://localhost:3000`. */\n  baseUrl: string;\n  /** Optional fetch override (used by tests to route into an in-process app). */\n  fetch?: typeof fetch;\n}\n\nexport type ClientOptions = BaseClientOptions &\n  (\n    | {\n        /** Project (agent) API key — sent as the `x-api-key` header. */\n        apiKey: string;\n        accessToken?: never;\n        organizationId?: never;\n        projectId?: never;\n      }\n    | {\n        apiKey?: never;\n        /** Human OAuth token, or an async provider that refreshes it before each request. */\n        accessToken: string | (() => string | Promise<string>);\n        /** Explicit live Organization selected by the Human client. */\n        organizationId: string;\n        /** Explicit live Project selected by the Human client. */\n        projectId: string;\n      }\n  );\n\n/** The native RPC handler is mounted at `/api/v1` (the console appRouter owns\n *  `/api/v1/rpc`). Trim any trailing slash so we never produce `//api/v1`. */\nexport function resolveRpcUrl(baseUrl: string): string {\n  return `${baseUrl.replace(/\\/+$/, \"\")}/api/v1`;\n}\n\n/** Create a typed Open Connector client bound to a Project key or Human OAuth capability. */\nexport function createClient(opts: ClientOptions): OpenConnectorClient {\n  const link = new RPCLink({\n    url: resolveRpcUrl(opts.baseUrl),\n    headers:\n      \"apiKey\" in opts && opts.apiKey\n        ? { \"x-api-key\": opts.apiKey }\n        : async () => ({\n            authorization: `Bearer ${\n              typeof opts.accessToken === \"function\" ? await opts.accessToken() : opts.accessToken\n            }`,\n            \"x-organization-id\": opts.organizationId,\n            \"x-project-id\": opts.projectId,\n          }),\n    ...(opts.fetch ? { fetch: opts.fetch } : {}),\n  });\n  return createORPCClient(link);\n}\n","import { createError, type EvlogError } from \"evlog\";\n\nimport type { OpenConnectorClient } from \"./client\";\n\n/** Statuses that mean \"keep waiting\" — the OAuth round-trip is still in flight. */\nconst PENDING_STATUSES = new Set([\"pending\", \"initiated\"]);\n\nexport type ConnectErrorReason = \"timeout\" | \"failed\";\n\n/** A connect/wait failure: code `connect.timeout` | `connect.failed`. The last connection status is in the message. */\nexport function connectError(reason: ConnectErrorReason, message: string): EvlogError {\n  return createError({\n    code: reason === \"timeout\" ? \"connect.timeout\" : \"connect.failed\",\n    message,\n    status: reason === \"timeout\" ? 408 : 502,\n    why:\n      reason === \"timeout\"\n        ? \"The connection did not reach `active` before the timeout\"\n        : \"The connection reached a terminal non-active status\",\n    fix:\n      reason === \"timeout\"\n        ? \"Increase timeoutMs, or have the user finish provider authorization or credential entry\"\n        : \"Create a new connect link or re-initiate the connection\",\n  });\n}\n\nexport interface WaitOptions {\n  /** Give up after this many ms (default 120_000). */\n  timeoutMs?: number;\n  /** Poll cadence in ms (default 2_000). */\n  intervalMs?: number;\n  /** Injectable clock + sleep so the loop is deterministic under test. */\n  now?: () => number;\n  sleep?: (ms: number) => Promise<void>;\n}\n\n// Only the two methods the wait loop calls — lets callers (and tests) pass a\n// narrower object than the full client.\ntype ConnectClient = Pick<OpenConnectorClient, \"initiate\" | \"getConnection\">;\n\nconst defaultSleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));\n\n/**\n * Poll `getConnection` until it reaches `active`, mirroring Composio's\n * `waitForConnection`. Resolves with the active connection id; throws an\n * `EvlogError` (code `connect.failed` | `connect.timeout`) on a terminal-failure status or timeout.\n */\nexport async function waitForConnection(\n  client: ConnectClient,\n  connectionId: string,\n  opts: WaitOptions = {},\n): Promise<{ connectionId: string; status: \"active\" }> {\n  const timeoutMs = opts.timeoutMs ?? 120_000;\n  const intervalMs = opts.intervalMs ?? 2_000;\n  const now = opts.now ?? Date.now;\n  const sleep = opts.sleep ?? defaultSleep;\n  const deadline = now() + timeoutMs;\n\n  for (;;) {\n    const conn = await client.getConnection({ connectionId });\n    if (conn.status === \"active\") return { connectionId, status: \"active\" };\n    if (!PENDING_STATUSES.has(conn.status)) {\n      throw connectError(\"failed\", `connection ${connectionId} is ${conn.status}`);\n    }\n    if (now() >= deadline) {\n      throw connectError(\n        \"timeout\",\n        `timed out after ${timeoutMs}ms waiting for connection ${connectionId} (last status: ${conn.status})`,\n      );\n    }\n    await sleep(intervalMs);\n  }\n}\n\nexport interface ConnectOAuthOptions extends WaitOptions {\n  slug: string;\n  authConfigId?: string;\n  authMethodId?: string;\n  /** Project-local connector business partition; independent from the authenticated Human. */\n  userId: string;\n  scopes?: string[];\n  /** Called with the provider authorize URL the user must visit (if any). */\n  onRedirect?: (url: string) => void;\n  /** When true (default), poll until the connection is active before resolving. */\n  waitForActive?: boolean;\n}\n\nexport interface ConnectResult {\n  connectionId: string;\n  status: \"pending\" | \"active\";\n  redirectUrl?: string;\n}\n\n/**\n * Begin an OAuth2 connection and (by default) wait for it to become active.\n * The caller is responsible for getting the user to the `redirectUrl` (the CLI\n * opens it / prints it). With `waitForActive: false` it returns immediately\n * after `initiate`.\n */\nexport async function connectOAuth(\n  client: ConnectClient,\n  opts: ConnectOAuthOptions,\n): Promise<ConnectResult> {\n  const init = await client.initiate({\n    slug: opts.slug,\n    authConfigId: opts.authConfigId,\n    authMethodId: opts.authMethodId,\n    userId: opts.userId,\n    scopes: opts.scopes,\n  });\n  if (init.redirectUrl) opts.onRedirect?.(init.redirectUrl);\n\n  if (opts.waitForActive === false) {\n    return { connectionId: init.connectionId, status: \"pending\", redirectUrl: init.redirectUrl };\n  }\n  const done = await waitForConnection(client, init.connectionId, opts);\n  return { connectionId: done.connectionId, status: \"active\", redirectUrl: init.redirectUrl };\n}\n"],"mappings":";;;;;;AAyCA,SAAgB,cAAc,SAAyB;CACrD,OAAO,GAAG,QAAQ,QAAQ,QAAQ,EAAE,EAAE;AACxC;;AAGA,SAAgB,aAAa,MAA0C;CACrE,MAAM,OAAO,IAAI,QAAQ;EACvB,KAAK,cAAc,KAAK,OAAO;EAC/B,SACE,YAAY,QAAQ,KAAK,SACrB,EAAE,aAAa,KAAK,OAAO,IAC3B,aAAa;GACX,eAAe,UACb,OAAO,KAAK,gBAAgB,aAAa,MAAM,KAAK,YAAY,IAAI,KAAK;GAE3E,qBAAqB,KAAK;GAC1B,gBAAgB,KAAK;EACvB;EACN,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;CAC5C,CAAC;CACD,OAAO,iBAAiB,IAAI;AAC9B;;;;ACzDA,MAAM,mCAAmB,IAAI,IAAI,CAAC,WAAW,WAAW,CAAC;;AAKzD,SAAgB,aAAa,QAA4B,SAA6B;CACpF,OAAO,YAAY;EACjB,MAAM,WAAW,YAAY,oBAAoB;EACjD;EACA,QAAQ,WAAW,YAAY,MAAM;EACrC,KACE,WAAW,YACP,6DACA;EACN,KACE,WAAW,YACP,2FACA;CACR,CAAC;AACH;AAgBA,MAAM,gBAAgB,OAAe,IAAI,SAAe,MAAM,WAAW,GAAG,EAAE,CAAC;;;;;;AAO/E,eAAsB,kBACpB,QACA,cACA,OAAoB,CAAC,GACgC;CACrD,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,aAAa,KAAK,cAAc;CACtC,MAAM,MAAM,KAAK,OAAO,KAAK;CAC7B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,IAAI,IAAI;CAEzB,SAAS;EACP,MAAM,OAAO,MAAM,OAAO,cAAc,EAAE,aAAa,CAAC;EACxD,IAAI,KAAK,WAAW,UAAU,OAAO;GAAE;GAAc,QAAQ;EAAS;EACtE,IAAI,CAAC,iBAAiB,IAAI,KAAK,MAAM,GACnC,MAAM,aAAa,UAAU,cAAc,aAAa,MAAM,KAAK,QAAQ;EAE7E,IAAI,IAAI,KAAK,UACX,MAAM,aACJ,WACA,mBAAmB,UAAU,4BAA4B,aAAa,iBAAiB,KAAK,OAAO,EACrG;EAEF,MAAM,MAAM,UAAU;CACxB;AACF;;;;;;;AA2BA,eAAsB,aACpB,QACA,MACwB;CACxB,MAAM,OAAO,MAAM,OAAO,SAAS;EACjC,MAAM,KAAK;EACX,cAAc,KAAK;EACnB,cAAc,KAAK;EACnB,QAAQ,KAAK;EACb,QAAQ,KAAK;CACf,CAAC;CACD,IAAI,KAAK,aAAa,KAAK,aAAa,KAAK,WAAW;CAExD,IAAI,KAAK,kBAAkB,OACzB,OAAO;EAAE,cAAc,KAAK;EAAc,QAAQ;EAAW,aAAa,KAAK;CAAY;CAG7F,OAAO;EAAE,eAAc,MADJ,kBAAkB,QAAQ,KAAK,cAAc,IAAI,EAAA,CACxC;EAAc,QAAQ;EAAU,aAAa,KAAK;CAAY;AAC5F"}

package/dist/testing.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src = require("./src-19LKPmdg.cjs");
+exports.connectError = require_src.connectError;
+exports.connectOAuth = require_src.connectOAuth;
+exports.createClient = require_src.createClient;
+exports.resolveRpcUrl = require_src.resolveRpcUrl;
+exports.waitForConnection = require_src.waitForConnection;

package/dist/testing.d.cts

@@ -0,0 +1,2 @@
+import { a as connectError, c as ClientOptions, d as resolveRpcUrl, i as WaitOptions, l as OpenConnectorClient, n as ConnectOAuthOptions, o as connectOAuth, r as ConnectResult, s as waitForConnection, t as ConnectErrorReason, u as createClient } from "./index-96n68fp1.cjs";
+export { type ClientOptions, type ConnectErrorReason, type ConnectOAuthOptions, type ConnectResult, type OpenConnectorClient, type WaitOptions, connectError, connectOAuth, createClient, resolveRpcUrl, waitForConnection };

package/dist/testing.d.ts

@@ -0,0 +1,2 @@
+import { a as connectError, c as ClientOptions, d as resolveRpcUrl, i as WaitOptions, l as OpenConnectorClient, n as ConnectOAuthOptions, o as connectOAuth, r as ConnectResult, s as waitForConnection, t as ConnectErrorReason, u as createClient } from "./index-BXEKBblV.js";
+export { type ClientOptions, type ConnectErrorReason, type ConnectOAuthOptions, type ConnectResult, type OpenConnectorClient, type WaitOptions, connectError, connectOAuth, createClient, resolveRpcUrl, waitForConnection };

package/dist/testing.js

@@ -0,0 +1,2 @@
+import { a as resolveRpcUrl, i as createClient, n as connectOAuth, r as waitForConnection, t as connectError } from "./src-CvNjrj1s.js";
+export { connectError, connectOAuth, createClient, resolveRpcUrl, waitForConnection };

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@open-connector/sdk",
+  "version": "1.0.2",
+  "description": "Typed TypeScript SDK for the native Open Connector API",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/okxiaoliang4/open-connector.git",
+    "directory": "packages/sdk"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "testing": [
+        "./dist/testing.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./testing": {
+      "import": {
+        "types": "./dist/testing.d.ts",
+        "default": "./dist/testing.js"
+      },
+      "require": {
+        "types": "./dist/testing.d.cts",
+        "default": "./dist/testing.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "1.9.1",
+    "@orpc/client": "1.14.4",
+    "@orpc/contract": "1.14.4",
+    "evlog": "2.18.1",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "4.1.11",
+    "typescript": "6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.0",
+    "vite-plus": "0.3.0",
+    "vitest": "4.1.11",
+    "@open-connector/api-contracts": "0.0.0",
+    "@open-connector/config": "0.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "pnpm run build:esm && pnpm run build:cjs",
+    "build:esm": "vp pack src/index.ts src/testing.ts --dts.eager --dts.generator tsc --dts.resolver tsc --format esm --sourcemap --platform neutral",
+    "build:cjs": "vp pack src/index.ts src/testing.ts --dts.eager --dts.generator tsc --dts.resolver tsc --format cjs --sourcemap --platform neutral --no-clean",
+    "test": "vp test run",
+    "test:coverage": "vp test run --coverage",
+    "check-types": "tsc --noEmit"
+  }
+}