@cosmoops/connect-sdk 0.3.0 → 0.7.0

package/dist/esm/next/index.js

@@ -1,13 +1,18 @@
+import { cache } from "react";
 import { ConnectClient } from "../server/client.js";
 import { createConnectHandler } from "../server/handler.js";
 /**
  * Plug-and-play wiring for Next.js.
  *
  * Everything below is server-side. Nothing here is *statically* imported from
- * `next`, so this module loads in App Router route handlers, the Node runtime
- * and the edge runtime alike - and needs no peer dependency. The one place
- * that does reach for `next/headers` does it behind a dynamic import, inside
- * the function that needs it, and says so when it isn't there.
+ * `next` itself, so this module loads in App Router route handlers, the Node
+ * runtime and the edge runtime alike without a `next` peer dependency. The
+ * one place that does reach for `next/headers` (or, in `requireConnectSession`,
+ * `next/navigation`) does it behind a dynamic import, inside the function that
+ * needs it, and says so when it isn't there. `react` is a real, static
+ * dependency though - `getConnectSession`'s automatic per-request memoization
+ * (below) is built on its `cache()`, which every App Router project already
+ * has.
  *
  * The whole integration is two files:
  *
@@ -33,7 +38,7 @@ import { createConnectHandler } from "../server/handler.js";
  * | `CONNECT_SESSION_COOKIE` | no | session cookie name |
  *
  * Register `{your origin}/api/connect/callback` as a redirect URI in the
- * service's Setup tab. That is the only step this cannot do for you.
+ * application's Integration tab. That is the only step this cannot do for you.
  *
  * No `next.config.ts` changes needed either, including `transpilePackages`:
  * `dist/` is already ES2022 with `"use client"` hoisted to the top of every
@@ -198,6 +203,35 @@ async function requestFromHeaders() {
     const proto = incoming.get("x-forwarded-proto") ?? (host.startsWith("localhost") ? "http" : "https");
     return new Request(`${proto}://${host}/`, { headers: incoming });
 }
+async function readSession(request, options) {
+    const store = options.session ?? cookieSessionStore();
+    const token = await store.read(request);
+    if (!token)
+        return null;
+    try {
+        return await (options.client ?? connectClient()).identity.getUser(token);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The ambient case - no explicit `request`, default client, default cookie
+ * store - wrapped in React's `cache()` so every call in the same request
+ * shares one round trip to Connect. A layout reading the session for a nav
+ * avatar and the page beneath it reading it again for a role check hit this
+ * exact function; without the wrapper that's two live reads of the same
+ * answer.
+ *
+ * Deliberately its own zero-argument function rather than `cache()` wrapping
+ * `getConnectSession` directly - `cache()` keys on argument identity, and
+ * `getConnectSession`'s default `options = {}` is a fresh object on every
+ * call, so wrapping it as-is would never hit the cache for the very call
+ * pattern this exists to speed up.
+ */
+const cachedAmbientSession = cache(async () => {
+    return readSession(await requestFromHeaders(), {});
+});
 /**
  * The signed-in user for a Server Component, Route Handler or Server Action,
  * or `null`.
@@ -208,6 +242,9 @@ async function requestFromHeaders() {
  * if (!session) redirect("/api/connect/signin?next=/dashboard");
  * ```
  *
+ * `requireConnectSession()` below is that exact check in one call, for the
+ * common case of "redirect if signed out."
+ *
  * Pass a `Request` to use it somewhere `next/headers` does not exist - a
  * framework-agnostic handler, a test, a custom server. Both forms take the
  * same path afterwards; the argument is only how the cookie is found.
@@ -219,18 +256,61 @@ async function requestFromHeaders() {
  *
  * Returns `null` for every failure - an expired session and a missing one both
  * mean "not signed in", and a page guard should not need a try/catch.
+ *
+ * **Memoized per request for the plain, zero-argument call** - the shape
+ * every page, layout and Server Action actually uses - via React's `cache()`.
+ * Passing an explicit `request`, `client` or `session` bypasses the cache
+ * and always makes a live call: those are for tests and non-ambient
+ * callers, where a fresh read every time is the point, not an oversight.
  */
 export async function getConnectSession(request, options = {}) {
-    const store = options.session ?? cookieSessionStore();
-    const token = await store.read(request ?? (await requestFromHeaders()));
-    if (!token)
-        return null;
-    try {
-        return await (options.client ?? connectClient()).identity.getUser(token);
-    }
-    catch {
-        return null;
-    }
+    if (!request && !options.client && !options.session)
+        return cachedAmbientSession();
+    return readSession(request ?? (await requestFromHeaders()), options);
+}
+/**
+ * `getConnectSession()`, minus the boilerplate of checking it and redirecting
+ * yourself:
+ *
+ * ```tsx
+ * // app/dashboard/page.tsx
+ * const session = await requireConnectSession();
+ * ```
+ *
+ * Redirects to `/signin` under the same `basePath` as `getConnectSession`'s
+ * default (`/api/connect`) when signed out - pass `signInPath` if you mounted
+ * the bridge somewhere else, and `next` to send the visitor back to where
+ * they were once they're signed in. Only sensible in a Server Component,
+ * Route Handler or Server Action, the same three places `redirect()` from
+ * `next/navigation` itself works.
+ *
+ * A thin wrapper, not a framework of its own - reach for `getConnectSession`
+ * plus your own check when "not signed in" isn't "redirect to sign-in"
+ * (an API route returning 401, say). Role and entitlement checks stay
+ * outside this function on purpose: `session.applicationRole.granted` and
+ * `connect.entitlements.*` are one line each on top of the session this
+ * already gives you, and where that line redirects (a plans page, a
+ * "forbidden" screen) is a decision only your app can make - see
+ * "Authentication & authorization" for the pattern.
+ */
+export async function requireConnectSession(request, options = {}) {
+    const session = await getConnectSession(request, options);
+    if (session)
+        return session;
+    const signIn = options.signInPath ?? "/api/connect/signin";
+    return redirectTo(options.next ? `${signIn}?next=${encodeURIComponent(options.next)}` : signIn);
+}
+/**
+ * `next/navigation`'s `redirect()`, imported the same dynamic way as
+ * `next/headers` above and for the same reason: no static dependency on
+ * `next`'s own types at this package's build time. Typed by hand rather than
+ * imported, since that's the only way to erase them - `redirect()` itself is
+ * typed `never`, which is what lets `requireConnectSession` return here
+ * without its own `return` after the call.
+ */
+async function redirectTo(url) {
+    const { redirect } = (await import("next/navigation"));
+    return redirect(url);
 }
 export { createConnectHandler } from "../server/handler.js";
 export { ConnectClient } from "../server/client.js";

package/dist/esm/server/client.js

@@ -5,11 +5,13 @@ import { BillingResource } from "./resources/billing.js";
 import { DriveResource } from "./resources/drive.js";
 import { EntitlementsResource } from "./resources/entitlements.js";
 import { IdentityResource } from "./resources/identity.js";
+import { IntegrationsResource } from "./resources/integrations.js";
 import { LogsResource } from "./resources/logs.js";
+import { AnalyticsResource } from "./resources/analytics.js";
 import { OtpResource } from "./resources/otp.js";
 import { SessionsResource } from "./resources/sessions.js";
 export const DEFAULT_BASE_URL = "https://connect.cosmoops.com";
-const SERVICE_API_PREFIX = "/api/v1/service";
+const APPLICATION_API_PREFIX = "/api/v1/application";
 /**
  * Refuses to build a client in a browser.
  *
@@ -38,9 +40,9 @@ function assertNotBrowser() {
         "in browser code instead; it talks to your own origin and holds no credential.");
 }
 /**
- * The CosmoOps Connect service-partner API.
+ * The CosmoOps Connect application-partner API.
  *
- * Covers `/api/v1/service/*` and nothing else - the surface a service platform
+ * Covers `/api/v1/application/*` and nothing else - the surface an application platform
  * integrates against. Connect's internal API is not part of this package and
  * never will be.
  *
@@ -51,7 +53,7 @@ function assertNotBrowser() {
  * });
  *
  * const session = await connect.identity.exchangeCode({ code, redirectUri });
- * const { ready } = await connect.entitlements.getReadiness(session.user.organizationId);
+ * const { ready } = await connect.entitlements.getReadiness(session.user.workspaceId);
  * ```
  *
  * Every failure throws a `ConnectError` carrying a stable `code`. Nothing here
@@ -60,32 +62,36 @@ function assertNotBrowser() {
 export class ConnectClient {
     /** "Login with Connect" - the OAuth2 handshake and the session after it. */
     identity;
-    /** What a signed-in member may do on your service. */
+    /** What a signed-in member may do on your application. */
     access;
-    /** The services an organization can open - for a launcher grid. */
+    /** The applications a workspace can open - for a launcher grid. */
     apps;
-    /** Whether a workspace may use your service, and on what plan. */
+    /** Whether a workspace may use your application, and on what plan. */
     entitlements;
     /** Your plan catalog, and metering usage against add-on balances. */
     billing;
-    /** Files in an organization's Drive. */
+    /** Files in a workspace's Drive. */
     drive;
     /** RAG chat and structured extraction. */
     ai;
     /** WhatsApp/SMS phone verification. */
     otp;
-    /** Feature events into the Console's audit log, filterable to your service. */
+    /** Feature events into the Console's audit log, filterable to your application. */
     logs;
-    /** This Connect account's own login sessions - account-wide, not scoped to this service. Requires the `sessions:manage` scope. */
+    /** Emit product events and read back this application's aggregated numbers. */
+    analytics;
+    /** This Connect account's own login sessions - account-wide, not scoped to this application. Requires the `sessions:manage` scope. */
     sessions;
+    /** Composio-hosted third-party connections (Google Calendar, Slack, ...) a workspace has connected. */
+    integrations;
     constructor(options) {
         assertNotBrowser();
         if (!options.apiKey) {
-            throw new TypeError("ConnectClient requires `apiKey` - the plaintext shown once in the Setup tab.");
+            throw new TypeError("ConnectClient requires `apiKey` - the plaintext shown once in the Integration tab.");
         }
         const appBaseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
         const transport = {
-            baseUrl: `${appBaseUrl}${SERVICE_API_PREFIX}`,
+            baseUrl: `${appBaseUrl}${APPLICATION_API_PREFIX}`,
             apiKey: options.apiKey,
             timeoutMs: options.timeoutMs ?? 20_000,
             maxRetries: options.maxRetries ?? 2,
@@ -93,7 +99,7 @@ export class ConnectClient {
             userAgent: `cosmoops-connect-sdk/${SDK_VERSION}`,
         };
         // `authorizeUrl` points at the app, not the API prefix - it is a browser
-        // redirect, not a service call, so identity takes both.
+        // redirect, not an application call, so identity takes both.
         this.identity = new IdentityResource(transport, options.clientId ?? null, appBaseUrl);
         this.access = new AccessResource(transport);
         this.apps = new AppsResource(transport);
@@ -103,8 +109,10 @@ export class ConnectClient {
         this.ai = new AiResource(transport);
         this.otp = new OtpResource(transport);
         this.logs = new LogsResource(transport);
+        this.analytics = new AnalyticsResource(transport);
         this.sessions = new SessionsResource(transport, options.clientId ?? null);
+        this.integrations = new IntegrationsResource(transport);
     }
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export const SDK_VERSION = "0.3.0";
+export const SDK_VERSION = "0.7.0";

package/dist/esm/server/handler.js

@@ -91,9 +91,9 @@ function redirect(location, cookies = []) {
  * export { handler as GET, handler as POST };
  * ```
  *
- * Every route resolves the organization from the caller's *own* session, never
+ * Every route resolves the workspace from the caller's *own* session, never
  * from a query parameter. A browser must not be able to ask about an
- * organization it is not signed into, and a client-supplied `organizationId`
+ * workspace it is not signed into, and a client-supplied `workspaceId`
  * is exactly that hole.
  */
 export function createConnectHandler(options) {
@@ -101,6 +101,7 @@ export function createConnectHandler(options) {
     const { client, session } = options;
     const defaultRedirect = options.defaultRedirect ?? "/";
     const stateCookieName = options.stateCookieName ?? "connect_oauth_state";
+    const silentCookieName = `${stateCookieName}_silent`;
     const callbackPath = `${basePath}/callback`;
     /**
      * Short-lived, httpOnly, and `SameSite=Lax` - `Strict` would not be sent on
@@ -121,6 +122,32 @@ export function createConnectHandler(options) {
             .filter(Boolean)
             .join("; ");
     }
+    /**
+     * Marks the in-flight round trip as a silent (`prompt=none`) one, so the
+     * callback can tell a *probe that found nobody* from a *sign-in that
+     * failed*. The two arrive as the identical `error=login_required`, and they
+     * need opposite handling - see the callback.
+     *
+     * A cookie of its own rather than a flag folded into the state cookie:
+     * that one is parsed by splitting on `:` with the destination URL rejoined
+     * from the remainder, so smuggling a third field through it is exactly the
+     * kind of encoding trick that breaks the first time a `next` URL contains
+     * something unexpected. Same attributes and lifetime as the state cookie
+     * it travels beside.
+     */
+    function silentCookie(value, secure) {
+        const cleared = value === "";
+        return [
+            `${silentCookieName}=${encodeURIComponent(value)}`,
+            `Path=${basePath}`,
+            "HttpOnly",
+            "SameSite=Lax",
+            secure ? "Secure" : "",
+            cleared ? "Max-Age=0" : "Max-Age=900",
+        ]
+            .filter(Boolean)
+            .join("; ");
+    }
     async function requireToken(request) {
         const token = await session.read(request);
         if (!token) {
@@ -133,7 +160,7 @@ export function createConnectHandler(options) {
         }
         return token;
     }
-    /** Signed-in identity plus the organization it belongs to - the first read every other route needs. */
+    /** Signed-in identity plus the workspace it belongs to - the first read every other route needs. */
     async function whoami(request) {
         return client.identity.getUser(await requireToken(request));
     }
@@ -143,30 +170,61 @@ export function createConnectHandler(options) {
             // Signed out is a normal state for a page rendering a Login button, not
             // an error - `user: null` rather than a 401 the client must catch.
             if (!token)
-                return json({ user: null, subscription: null, serviceRole: null });
+                return json({ user: null, subscription: null, applicationRole: null });
             return json(await client.identity.getUser(token));
         },
         "GET /entitlements": async (request) => {
             const { user } = await whoami(request);
             const [readiness, subscription] = await Promise.all([
-                client.entitlements.getReadiness(user.organizationId),
-                client.entitlements.getSubscription(user.organizationId),
+                client.entitlements.getReadiness(user.workspaceId),
+                client.entitlements.getSubscription(user.workspaceId),
             ]);
             return json({ readiness, subscription });
         },
         "GET /plans": async () => json(await client.billing.listPlans()),
-        // Organization comes from the caller's own session, same as every other
+        // Workspace comes from the caller's own session, same as every other
         // route here - a browser must not be able to ask what another workspace
         // has left.
         "GET /addons": async (request) => {
             const { user } = await whoami(request);
-            return json(await client.billing.getAddonUsage(user.organizationId));
+            return json(await client.billing.getAddonUsage(user.workspaceId));
         },
         "GET /apps": async (request) => {
             const { user } = await whoami(request);
-            return json({ apps: await client.apps.list(user.organizationId) });
+            return json({ apps: await client.apps.list(user.workspaceId) });
         },
-        // Account-wide, not scoped to this service - see `SessionsResource`'s
+        "GET /integrations": async (request) => {
+            const { user } = await whoami(request);
+            return json({ toolkits: await client.integrations.list(user.workspaceId) });
+        },
+        "POST /integrations/connect": async (request) => {
+            const { user } = await whoami(request);
+            const body = (await request.json().catch(() => null));
+            if (!body?.toolkitSlug || !body?.returnUrl) {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "toolkitSlug and returnUrl are required",
+                    endpoint: "POST /integrations/connect",
+                });
+            }
+            return json(await client.integrations.initiateConnect(user.workspaceId, body.toolkitSlug, body.returnUrl));
+        },
+        "POST /integrations/disconnect": async (request) => {
+            const { user } = await whoami(request);
+            const body = (await request.json().catch(() => null));
+            if (!body?.toolkitSlug) {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "toolkitSlug is required",
+                    endpoint: "POST /integrations/disconnect",
+                });
+            }
+            await client.integrations.disconnect(user.workspaceId, body.toolkitSlug);
+            return json({ ok: true });
+        },
+        // Account-wide, not scoped to this application - see `SessionsResource`'s
         // doc comment. `requireToken` alone identifies the caller; the target
         // `sessionId` on the revoke routes travels in the JSON body, not the
         // URL, so the exact-match routes table above never needs a dynamic
@@ -205,14 +263,19 @@ export function createConnectHandler(options) {
             const secure = url.protocol === "https:";
             const state = createState();
             const next = safeRedirect(url.searchParams.get("next"), defaultRedirect);
+            const requestedPrompt = url.searchParams.get("prompt");
+            const prompt = requestedPrompt === "create" || requestedPrompt === "none" ? requestedPrompt : undefined;
             const authorizeUrl = client.identity.authorizeUrl({
                 redirectUri: `${url.origin}${callbackPath}`,
                 state,
-                ...(url.searchParams.get("prompt") === "create" ? { prompt: "create" } : {}),
+                ...(prompt ? { prompt } : {}),
             });
             // State and destination travel together in one cookie so the callback
             // cannot end up with one and not the other.
-            return redirect(authorizeUrl, [stateCookie(`${state}:${next}`, secure)]);
+            const cookies = [stateCookie(`${state}:${next}`, secure)];
+            if (prompt === "none")
+                cookies.push(silentCookie("1", secure));
+            return redirect(authorizeUrl, cookies);
         },
         /**
          * The other end of the round trip. Verifies `state`, exchanges the code,
@@ -229,10 +292,29 @@ export function createConnectHandler(options) {
             if (!cookieState || !sameState(cookieState, returnedState)) {
                 // Either a forged callback or a genuinely stale tab. Neither should
                 // mint a session, and neither is worth an error page.
-                return redirect(`${next}${next.includes("?") ? "&" : "?"}connect_error=state_mismatch`, [clearState]);
+                return redirect(`${next}${next.includes("?") ? "&" : "?"}connect_error=state_mismatch`, [
+                    clearState,
+                    silentCookie("", secure),
+                ]);
             }
+            const wasSilent = readCookie(request, silentCookieName) === "1";
+            const clearSilent = silentCookie("", secure);
             const error = url.searchParams.get("error");
             if (error) {
+                // A silent (`prompt=none`) probe that came back empty-handed. All
+                // three of its outcomes mean the same thing to the app - "carry on
+                // signed out" - so it returns to `next` quietly: no retry, and no
+                // `connect_error`, because nothing went wrong.
+                //
+                // Getting this wrong is not subtle. The retry below fires on exactly
+                // the `login_required` a silent probe returns, so without this branch
+                // every silent attempt for a signed-out visitor would escalate itself
+                // into a full interactive sign-in redirect - turning "quietly check
+                // if they're already here" into "force everyone to log in", which is
+                // the precise opposite of the feature.
+                if (wasSilent) {
+                    return redirect(next, [clearState, clearSilent]);
+                }
                 // `login_required` is normal traffic, not a fault: a new account gets
                 // pulled out to their inbox to verify, and the ~15 minute request
                 // expires before they return. Connect has already signed them in, so
@@ -242,15 +324,16 @@ export function createConnectHandler(options) {
                     const retry = new URL(`${url.origin}${basePath}/signin`);
                     retry.searchParams.set("next", next);
                     retry.searchParams.set("connect_retry", "1");
-                    return redirect(retry.toString(), [clearState]);
+                    return redirect(retry.toString(), [clearState, clearSilent]);
                 }
                 return redirect(`${next}${next.includes("?") ? "&" : "?"}connect_error=${encodeURIComponent(error)}`, [
                     clearState,
+                    clearSilent,
                 ]);
             }
             const code = url.searchParams.get("code");
             if (!code) {
-                return redirect(`${next}${next.includes("?") ? "&" : "?"}connect_error=missing_code`, [clearState]);
+                return redirect(`${next}${next.includes("?") ? "&" : "?"}connect_error=missing_code`, [clearState, clearSilent]);
             }
             const result = await client.identity.exchangeCode({
                 code,
@@ -259,7 +342,7 @@ export function createConnectHandler(options) {
             // Verified before the session is stored, not after - an unverifiable
             // token must never become a signed-in user.
             await client.identity.verifyIdToken(result.idToken);
-            const response = redirect(next, [clearState]);
+            const response = redirect(next, [clearState, clearSilent]);
             await session.write(request, response, result.sessionToken);
             return response;
         },

package/dist/esm/server/http.js

@@ -40,7 +40,7 @@ function parseRetryAfterMs(response) {
     return Number.isFinite(seconds) ? Math.max(0, seconds) * 1000 : null;
 }
 /**
- * Both error dialects, one shape. `/api/v1/service/*` answers
+ * Both error dialects, one shape. `/api/v1/application/*` answers
  * `{ error: { code, message } }`; the `/sso/*` endpoints answer OAuth2's
  * `{ error, error_description }`.
  */

package/dist/esm/server/index.js

@@ -8,3 +8,8 @@
 export { ConnectClient, DEFAULT_BASE_URL, SDK_VERSION } from "./client.js";
 export { createConnectHandler } from "./handler.js";
 export { createState } from "./resources/identity.js";
+/**
+ * Webhook verification and a ready-made POST route. Server-only for the
+ * obvious reason: the signing secret must never reach a browser bundle.
+ */
+export { createConnectWebhookHandler, verifyConnectWebhook, } from "./webhooks.js";

package/dist/esm/server/resources/access.js

@@ -1,5 +1,5 @@
 import { pathSegment, request } from "../http.js";
-/** What a signed-in member may do on your service, and the role catalog behind it. */
+/** What a signed-in member may do on your application, and the role catalog behind it. */
 export class AccessResource {
     transport;
     constructor(transport) {
@@ -14,10 +14,10 @@ export class AccessResource {
         return request(this.transport, {
             method: "GET",
             path: `/rbac/users/${pathSegment(userId, "userId")}/roles`,
-            query: { organizationId: input.organizationId },
+            query: { workspaceId: input.workspaceId },
         });
     }
-    /** Your service's own permission catalog and role definitions - the definitions `getUserRoles` resolves against. */
+    /** Your application's own permission catalog and role definitions - the definitions `getUserRoles` resolves against. */
     listRoles() {
         return request(this.transport, { method: "GET", path: "/roles" });
     }

package/dist/esm/server/resources/ai.js

@@ -1,5 +1,5 @@
 import { request } from "../http.js";
-/** RAG chat and structured extraction against an organization's data. */
+/** RAG chat and structured extraction against a workspace's data. */
 export class AiResource {
     transport;
     constructor(transport) {

package/dist/esm/server/resources/analytics.js

@@ -0,0 +1,62 @@
+import { request } from "../http.js";
+/**
+ * Your application's own analytics: emit product events, and read back the daily
+ * numbers Connect aggregates from them.
+ *
+ * There is no way to name an application in either call. The scope is always the one
+ * your API key belongs to - that is the endpoint's security model, not an
+ * omission.
+ */
+export class AnalyticsResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * Daily series for the requested metrics, up to 90 days.
+     *
+     * **Throws on failure**, unlike `emit` below. A read whose result you are
+     * about to render has to be able to say "I could not load"; silently
+     * returning an empty series would draw a chart of zeroes.
+     */
+    async series(query) {
+        const params = new URLSearchParams({
+            metrics: query.metrics.join(","),
+            from: query.from,
+            to: query.to,
+        });
+        return request(this.transport, {
+            method: "GET",
+            path: `/analytics?${params.toString()}`,
+        });
+    }
+    /**
+     * Never throws - the same judgement `LogsResource.write` makes, for the same
+     * reason: telemetry that takes down the code path it was observing is worse
+     * than a lost event. A failure is reported through `delivered`.
+     *
+     * Up to 50 events per call. Pass `sessionToken` on an event to attribute it
+     * to the signed-in user; without one it still lands, just unattributed.
+     */
+    async emit(events) {
+        const normalized = events.map((event) => ({
+            ...event,
+            occurredAt: event.occurredAt instanceof Date ? event.occurredAt.toISOString() : event.occurredAt,
+        }));
+        try {
+            const result = await request(this.transport, {
+                method: "POST",
+                path: "/events",
+                json: { events: normalized },
+            });
+            return {
+                delivered: true,
+                accepted: result?.accepted ?? events.length,
+                attributed: result?.attributed ?? 0,
+            };
+        }
+        catch {
+            return { delivered: false, accepted: 0, attributed: 0 };
+        }
+    }
+}

package/dist/esm/server/resources/apps.js

@@ -1,5 +1,5 @@
 import { request } from "../http.js";
-/** The services an organization can open - the data behind a launcher grid. */
+/** The applications a workspace can open - the data behind a launcher grid. */
 export class AppsResource {
     transport;
     constructor(transport) {
@@ -7,13 +7,13 @@ export class AppsResource {
     }
     /**
      * Launchable apps only, so a grid tile is never a dead end. The calling
-     * service is included and flagged `isCurrent` rather than filtered out.
+     * application is included and flagged `isCurrent` rather than filtered out.
      */
-    async list(organizationId) {
+    async list(workspaceId) {
         const result = await request(this.transport, {
             method: "GET",
             path: "/apps",
-            query: { organizationId },
+            query: { workspaceId },
         });
         // `?? []` for the same reason `billing.listPlans` has it: this is a
         // collection every caller immediately maps or measures, and a body without

package/dist/esm/server/resources/billing.js

@@ -7,7 +7,7 @@ export class BillingResource {
         this.transport = transport;
     }
     /**
-     * Your service's active plans - render live pricing instead of hardcoding it.
+     * Your application's active plans - render live pricing instead of hardcoding it.
      *
      * `features` is normalised on the way out: Connect used to send bare keys
      * and now sends `{ key, name, description }`, and this SDK is versioned
@@ -25,7 +25,7 @@ export class BillingResource {
         };
     }
     /**
-     * What is left of every consumable add-on on an organization's
+     * What is left of every consumable add-on on a workspace's
      * subscription - the read half of `consumeAddon`.
      *
      * Needs a key scoped to `addons:read`, which is separate from
@@ -35,10 +35,10 @@ export class BillingResource {
      * Returns an empty `addons` array rather than throwing when there is
      * nothing to meter, so a caller can render it unconditionally.
      */
-    async getAddonUsage(organizationId) {
+    async getAddonUsage(workspaceId) {
         const response = await request(this.transport, {
             method: "GET",
-            path: `/addons/organizations/${pathSegment(organizationId, "organizationId")}`,
+            path: `/addons/workspaces/${pathSegment(workspaceId, "workspaceId")}`,
         });
         // Normalised, not passed through: the promise above resolves for any 2xx,
         // and `ConnectUsageMeter` reads `addons` straight off it. A body without
@@ -49,7 +49,7 @@ export class BillingResource {
     }
     /**
      * Debit a consumable add-on's per-cycle balance on behalf of an
-     * organization's users. Call it at whatever cadence your usage happens.
+     * workspace's users. Call it at whatever cadence your usage happens.
      *
      * An `Idempotency-Key` is always sent, generated per call when you do not
      * supply one: a balance cannot be un-spent, so a retried consume without a