@olympusoss/sdk in your TypeScript app

npm install @olympusoss/sdk
# or
bun add @olympusoss/sdk

import { OlympusClient } from "@olympusoss/sdk";

export const olympus = new OlympusClient({
  publicUrl: process.env.OLYMPUS_PUBLIC_URL!,     // https://ciam.your-domain
  adminUrl: process.env.OLYMPUS_ADMIN_URL,        // backend-only; omit for browser
  clientId: process.env.OLYMPUS_CLIENT_ID!,
  clientSecret: process.env.OLYMPUS_CLIENT_SECRET, // confidential clients only
});

const session = await olympus.toSession();
// throws if no session; .traits, .identity_id, .aal available

const url = await olympus.buildAuthorizationUrl({
  scope: ["openid", "offline_access", "profile", "email"],
  redirectUri: "/callback",
  pkce: true,
});
window.location.href = url;

const { accessToken, idToken, refreshToken } = await olympus.exchangeCodeForTokens(code);
// PKCE verifier is auto-managed in sessionStorage

const refreshed = await olympus.refreshToken();
// Stored access_token / refresh_token rotated

const intro = await olympus.introspect(accessToken);
// intro.active, .sub, .scope, .client_id, ...

const identities = await olympus.admin.identities.list({
  page: 1,
  perPage: 50,
  filter: 'traits.email eq "alice@example.com"',
});

const identity = await olympus.admin.identities.create({
  schema_id: "default",
  traits: { email: "alice@example.com", first_name: "Alice" },
  credentials: {
    password: { config: { password: "RandomTempPass123!" } }
  },
  state: "active",
});

const link = await olympus.admin.identities.createRecoveryLink({
  identity_id: identityId,
  expires_in: "1h",
});
// Email this link to the user

import type { Session, Identity, AdminIdentitiesListResponse } from "@olympusoss/sdk";

function describe(id: Identity) {
  return `${id.traits.first_name} ${id.traits.last_name}`;
}

import { OlympusError, NotFoundError, ValidationError } from "@olympusoss/sdk";

try {
  await olympus.toSession();
} catch (err) {
  if (err instanceof NotFoundError) {
    // not logged in
  } else if (err instanceof OlympusError) {
    // other Olympus error
  } else {
    throw err;
  }
}

npm install @olympusoss/sdk-react

import { OlympusProvider, useSession, useLogin } from "@olympusoss/sdk-react";

function App() {
  return (
    <OlympusProvider client={olympus}>
      <Profile />
    </OlympusProvider>
  );
}

function Profile() {
  const { session, loading } = useSession();
  if (loading) return <Spinner />;
  if (!session) return <a href="/login">Sign in</a>;
  return <p>Hi {session.identity.traits.first_name}</p>;
}

// server.ts
export const olympusServer = new OlympusClient({ /* with admin */ });

// client.ts
export const olympusBrowser = new OlympusClient({ /* without admin */ });

// app/api/whoami/route.ts
import { olympusServer } from "@/lib/olympus";
import { cookies } from "next/headers";

export async function GET() {
  const session = await olympusServer.toSession(cookies().toString());
  return Response.json(session);
}

app.use(olympus.middleware());  // sets req.session