Files
skills/public/hip-0111.html
zeekayandHanzo Dev 9e10c1c10e Each llms index points at the other two
hanzoskills.com/llms.txt now opens with the install line, the API
reference index and the company index, so an agent that lands on any
one of the three can find the rest.

robots.txt claimed 537 documents while llms.txt counts 920. The number
is gone from robots.txt; llms.txt derives it.

public/ is regenerated from scripts/site.py, which it had fallen
behind: the copy-prompt menu and agent bar were in the generator and
not in the committed pages. tests/site.mjs passes against the result.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-11 00:27:59 -07:00

362 lines
47 KiB
HTML

<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>hip-0111</title>
<meta name="color-scheme" content="dark">
<style>
/* Committed to one visual world: a dark instrument panel. No light variant —
the dot field and the hairline rules only read on black, and a naive
inversion would wash both out. Every colour is painted explicitly so the page
never borrows a host background. */
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
:root{
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
--font-zen-pixel-square:'Zen Pixel Square',monospace;
--mono:var(--font-zen-mono);
--sans:var(--font-zen-sans);
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
--r:999px; --r-soft:14px;
}
*{box-sizing:border-box}
html{-webkit-text-size-adjust:100%}
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
/* The dot field. A halftone made of one repeating radial-gradient, faded out
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
/* No overflow clip here: the dot field is inset to the box already, and a clip
would cut off the copy-prompt menu. */
.hero{position:relative;border-bottom:1px solid var(--line)}
.hero::before{content:"";position:absolute;inset:0;
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
background-size:7px 7px;
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
pointer-events:none}
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
nav{border-bottom:1px solid var(--line)}
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
justify-content:space-between;align-items:center;gap:1rem}
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--ink);text-decoration:none;
display:inline-flex;align-items:center;gap:.6rem}
.brand i{font-style:normal;color:var(--faint)}
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--soft);text-decoration:none}
nav a.up:hover{color:var(--ink)}
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
h1 em{font-style:normal;color:var(--faint)}
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
line-height:1.2;font-weight:400}
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
.btn.solid:hover{background:#d8d8d4}
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
/* Copy-prompt selector. Each row copies the prompt for its own target. */
.copy{position:relative;display:inline-flex}
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
padding:.4rem;display:flex;flex-direction:column;
box-shadow:0 12px 32px rgba(0,0,0,.75)}
.menu[hidden]{display:none}
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
white-space:nowrap}
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
.mi:hover .mark{color:var(--ink)}
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
letter-spacing:.1em;text-transform:uppercase}
/* Works-with bar: one scrolling row, name and mark per agent. */
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
display:flex;align-items:center}
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
-webkit-overflow-scrolling:touch;
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
.bar::-webkit-scrollbar{display:none}
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
text-decoration:none;background:var(--ground)}
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
.agent .mark{width:.95rem;height:.95rem}
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
p{margin:0 0 1rem;max-width:70ch}
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
li{margin:.22rem 0}
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
text-decoration-color:var(--line-hi)}
a:hover{text-decoration-color:var(--ink)}
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
display:block;overflow-x:auto}
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
.curl{display:block;background:var(--panel);border:1px solid var(--line);
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
white-space:pre;line-height:1.9}
.curl b{color:var(--ink);font-weight:400}
.curl i{font-style:normal;color:var(--faint)}
/* index */
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
#q:focus{outline:none;border-color:var(--soft)}
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
text-transform:uppercase;margin:0 0 2rem}
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
padding-bottom:.45rem}
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
border-radius:var(--r-soft);text-decoration:none}
.row:hover{background:#0a0a0a}
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
color:var(--faint);font-size:.85rem}
footer a{color:var(--soft)}
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
margin:0 0 2rem;font-size:.85rem}
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
border-bottom:1px solid var(--line);padding-bottom:.4rem}
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
.fmap a:hover{text-decoration:underline}
.fmap div{color:var(--faint);line-height:1.5}
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
@media (max-width:640px){
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
.btns{gap:.5rem}
.btn{padding:.75rem 1.15rem;font-size:.68rem}
.copy,.copy .btn{width:100%;justify-content:center}
.menu{left:0;right:0;min-width:0}
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
.strip b{border-right:0;padding-right:0}
.bar{width:100%}
}
</style>
<link rel="alternate" type="text/markdown" href="/hip-0111.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/hip-0111">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/hip-0111.md
Index: https://hanzoskills.com/llms.txt
Corpus: https://hanzoskills.com/all.md
Append .md to any path for the markdown twin. -->
<body>
<nav><div class="in">
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
<a class="up" href="/">All skills</a>
</div></nav>
<div class="wrap">
<h1>hip-0111</h1><p class="lede">HIP-111: Hanzo IAM Authentication Standard. Status Final. Hanzo architectural specification.</p><h1>HIP-0111: Hanzo IAM Authentication Standard</h1>
<h2>Abstract</h2>
<p>This is the one and only way an application authenticates a user, provisions an identity, or validates a token against Hanzo IAM. It defines the canonical IETF/RFC endpoint surface, the single approved client library (<code>@hanzo/iam</code>), the integration pattern for every supported framework, the application-registration rules, and the anti-patterns that are forbidden.</p>
<p><strong>RFC-standard only — no vendor compat.</strong> Every wire contract on this surface is an IETF RFC or OpenID Connect standard. There are NO verb aliases (<code>get-users</code>, <code>add-user</code>, <code>get-account</code>, <code>issue-user-token</code>, …), no bespoke &quot;verb&quot; REST, and no backward-compat shims, on iam or on any client. Where a capability has a standard, the standard IS the surface: identity provisioning is <strong>SCIM 2.0</strong> (RFC 7644/7643), delegated/on-behalf-of tokens are <strong>OAuth 2.0 Token Exchange</strong> (RFC 8693), account claims are <strong>OIDC UserInfo</strong>, token validation is <strong>Introspection</strong> (RFC 7662) + JWKS (RFC 7517). A client that needs a capability uses its RFC; if no RFC covers it, it is the authorization server&#x27;s internal concern (§6), never a new public &quot;verb&quot;.</p>
<p>HIP-0026 specifies the IAM <strong>server</strong> — the provider itself. This HIP specifies the <strong>wire contract</strong> — how everything talks to it. Where the two touch (endpoint paths, discovery, the token exchange), this HIP is authoritative and HIP-0026 follows it.</p>
<p>Hanzo IAM (<code>hanzoai/iam</code>) is a clean-room, standards-based OAuth 2.0 + OpenID Connect + SCIM 2.0 provider — original expression, no upstream fork — deployed once per brand. The Beego/xorm fork it replaced is retired to <code>hanzoai/iam-v1</code> and is out of every graph; a HIP describing Beego, xorm or a Postgres schema is describing that repository, not this one. IAM is deployed once per brand:</p>
<p>| Brand | IAM origin (<code>serverUrl</code>) | Login UI | |-------|--------------------------|----------| | Hanzo | <code>https://hanzo.id</code> | <code>hanzo.id</code> | | Lux | <code>https://lux.id</code> | <code>lux.id</code> | | Zoo | <code>https://zoo.id</code> | <code>zoo.id</code> | | Bootnode | <code>https://id.bootno.de</code> | <code>id.bootno.de</code> | | Pars | <code>https://pars.id</code> | <code>pars.id</code> |</p>
<p>The two columns hold the same host on every row, and that is the rule, not a coincidence: the authorization server answers on the origin it names as <code>issuer</code>, so <code>serverUrl</code> is always the brand&#x27;s identity host. <code>iam.hanzo.ai</code> is not that host — it serves the <code>200 text/html</code> SPA on every path, <code>/v1/iam/*</code> included, so a client pointed there resolves the catch-all described below and fails on content type. Discovery is the check: <code>https://hanzo.id/.well-known/openid-configuration</code> returns <code>application/json</code> with <code>issuer: https://hanzo.id</code>, and so does the copy served from <code>api.hanzo.ai</code>.</p>
<p>The library is brand-agnostic. You select the brand by setting <code>serverUrl</code>; nothing else changes.</p>
<p><strong>SDK</strong>: <a href="https://github.com/hanzo-js/iam"><code>@hanzo/iam</code></a> (npm, v0.11.0+) <strong>Source of truth for paths</strong>: <code>@hanzo/iam</code> → <code>src/paths.ts</code> → <code>OIDC_PATHS</code></p>
<h2>Motivation</h2>
<p>Every authentication regression in the estate has had one of three root causes:</p>
<ol><li><strong>Path drift</strong> — a client invented its own OIDC path (<code>/oauth/authorize</code>, <code>/api/login/oauth/access_token</code>, <code>/api/...</code>). IAM serves a <strong>200 <code>text/html</code> SPA catch-all for any unregistered path</strong>, so a wrong path returns an HTML body with a <code>200</code>, not a <code>404</code>. The OAuth library then dies on <code>content-type must be application/json</code> and the failure looks like a server bug. It is not; it is a client hitting the wrong URL.</li></ol>
<ol><li><strong>Discovery drift</strong> — a client used raw <code>better-auth</code> <code>genericOAuth({ discoveryUrl })</code>. Discovery resolution landed on the SPA catch-all HTML and the client wired itself to garbage endpoints.</li></ol>
<ol><li><strong>Hand-rolled OAuth</strong> — a team reimplemented PKCE, token exchange, or JWKS validation and got the audience check, the <code>S256</code> challenge, or the refresh rotation subtly wrong.</li></ol>
<p>All three vanish if there is exactly one library that owns exactly one set of paths, and every application uses it. That is this standard.</p>
<h2>Specification</h2>
<h3>1. The canonical OIDC endpoints</h3>
<p>These are the <strong>only</strong> paths. There is no <code>/oauth/<em></code>, no <code>/api/login/</em></code>, no <code>/api/</code> prefix. They are relative to the brand <code>serverUrl</code>.</p>
<p>| Purpose | Path | RFC / spec | |---------|------|------------| | OIDC discovery | <code>/.well-known/openid-configuration</code> | OIDC Discovery 1.0 | | AS metadata | <code>/.well-known/oauth-authorization-server</code> | RFC 8414 | | Authorize | <code>/v1/iam/oauth/authorize</code> | RFC 6749 §3.1 | | Token | <code>/v1/iam/oauth/token</code> | RFC 6749 §3.2 | | UserInfo | <code>/v1/iam/oauth/userinfo</code> | OIDC Core §5.3 | | Introspection | <code>/v1/iam/oauth/introspect</code> | RFC 7662 | | Revocation | <code>/v1/iam/oauth/revoke</code> | RFC 7009 | | JWKS | <code>/v1/iam/.well-known/jwks</code> | RFC 7517 | | Logout | <code>/v1/iam/oauth/logout</code> | OIDC RP-Initiated Logout | | Provisioning (SCIM) | <code>/v1/iam/scim/v2/{Users,Groups,…}</code> | RFC 7644/7643 (§8) |</p>
<p>The <strong>token endpoint</strong> (<code>/v1/iam/oauth/token</code>) dispatches ONLY standard <code>grant_type</code>s — <code>authorization_code</code> (RFC 6749 §4.1, always PKCE-bound), <code>refresh_token</code> (§6, rotating), <code>client_credentials</code> (§4.4), <code>password</code> (§4.3, confidential first-party only), and <code>urn:ietf:params:oauth:grant-type:token-exchange</code> (RFC 8693, §7 — delegation / on-behalf-of). There is exactly one token endpoint and one spelling of it; the legacy <code>access_token</code> alias is <strong>gone</strong> (a client posts to <code>token</code>, never <code>access_token</code>).</p>
<p>Mandatory parameters, everywhere:</p>
<ul><li><strong>PKCE <code>S256</code></strong> on every authorization request. <code>plain</code> is not permitted. Public clients (SPAs, native) require it; confidential clients use it too.</li><li><strong><code>client_secret_basic</code></strong> for confidential clients. HTTP Basic, not body params.</li><li><strong>Scopes</strong> <code>openid profile email</code> (+ <code>offline_access</code> for a refresh token).</li><li><strong><code>resource</code> / <code>audience</code></strong> (RFC 8707) name the resource server a token is minted for; the AS stamps <code>aud</code> accordingly and validators fail closed on a mismatch.</li><li><strong><code>iss</code></strong> is pinned per deployment (<code>IAM_ISSUER</code>, e.g. <code>https://hanzo.id</code>) so every token and the discovery document advertise ONE stable issuer regardless of request host — never steerable by <code>X-Forwarded-Host</code>.</li></ul>
<p>The discovery document MUST be self-consistent: <code>issuer</code>, <code>authorization_endpoint</code>, <code>token_endpoint</code>, <code>userinfo_endpoint</code>, and <code>jwks_uri</code> all share one origin (host-relative to the brand). The IAM knob that controls this is <code>originFrontend</code> in <code>app.prod.conf</code> — it MUST be empty so discovery is host-relative. A split-origin discovery document breaks strict OIDC clients (<code>openid-client</code>, NextAuth) that pin the issuer.</p>
<h3>2. The only integration: <code>@hanzo/iam</code></h3>
<p>JavaScript and TypeScript applications integrate <strong>only</strong> through <code>@hanzo/iam</code>. No application writes an OIDC path string. No application calls these endpoints by hand. The SDK holds the paths in one place (<code>OIDC_PATHS</code>) and every entry point reads from it; a failed discovery round-trip degrades to these same hard-coded values, so a client can never resolve to the SPA catch-all.</p>
<p>The SDK is split into per-environment entry points. Import the one that matches your runtime:</p>
<p>| Subpath | Surface | Use | |---------|---------|-----| | <code>@hanzo/iam</code> | <code>IamClient</code>, types | conditional Node/browser entry | | <code>@hanzo/iam/server</code> | <code>validateToken</code>, <code>getServerSession</code> | server-side JWT validation + session | | <code>@hanzo/iam/betterauth</code> | <code>iamProvider</code> | better-auth apps | | <code>@hanzo/iam/nextauth</code> | <code>IamProvider</code> | NextAuth / Auth.js apps | | <code>@hanzo/iam/react</code> | hooks, <code>OrgProjectSwitcher</code> | React SPAs | | <code>@hanzo/iam/browser</code> | <code>IAM</code> (PKCE client) | browser PKCE login | | <code>@hanzo/iam/passport</code> | <code>createIamPassportStrategy</code> | Node/Express + Passport |</p>
<h4>Server-side token validation (any backend)</h4>
<pre><code class="lang-ts">import { validateToken } from &quot;@hanzo/iam/server&quot;;
const result = await validateToken(accessToken, {
serverUrl: process.env.IAM_ENDPOINT!, // e.g. https://iam.hanzo.ai
clientId: process.env.IAM_CLIENT_ID!,
});
if (!result.ok) return unauthorized(result.reason);
const { userId, email, owner } = result; // owner = org slug → scope every query to it</code></pre>
<p><code>validateToken</code> discovers JWKS from <code>/.well-known/openid-configuration</code>, caches the key set per issuer, and verifies signature, <code>iss</code>, <code>aud</code>, and <code>exp</code>. Scope all multi-tenant data access to <code>owner</code>.</p>
<h4>Server session (App Router / RSC)</h4>
<pre><code class="lang-ts">import { getServerSession } from &quot;@hanzo/iam/server&quot;;
const session = await getServerSession({ serverUrl: process.env.IAM_ENDPOINT! });
if (!session) redirect(&quot;/login&quot;);</code></pre>
<h4>better-auth</h4>
<pre><code class="lang-ts">import { betterAuth } from &quot;better-auth&quot;;
import { genericOAuth } from &quot;better-auth/plugins&quot;;
import { iamProvider } from &quot;@hanzo/iam/betterauth&quot;;
export const auth = betterAuth({
plugins: [
genericOAuth({
config: [
iamProvider({
serverUrl: process.env.IAM_ENDPOINT!,
clientId: process.env.IAM_CLIENT_ID!,
clientSecret: process.env.IAM_CLIENT_SECRET!,
}),
],
}),
],
});</code></pre>
<p><code>iamProvider()</code> returns a config with <strong>explicit</strong> <code>authorization</code>, <code>token</code>, and <code>userinfo</code> endpoints (the canonical <code>/v1/iam/oauth/*</code> paths) — it never relies on discovery resolution. The registered redirect URI for this provider is <code>https://&lt;app-host&gt;/api/auth/oauth2/callback/hanzo</code>.</p>
<h4>NextAuth / Auth.js</h4>
<pre><code class="lang-ts">import { IamProvider } from &quot;@hanzo/iam/nextauth&quot;;
export default NextAuth({
providers: [
IamProvider({
serverUrl: process.env.IAM_ENDPOINT!,
clientId: process.env.IAM_CLIENT_ID!,
clientSecret: process.env.IAM_CLIENT_SECRET!,
checks: [&quot;state&quot;, &quot;pkce&quot;],
}),
],
});</code></pre>
<h4>React SPA (PKCE)</h4>
<pre><code class="lang-ts">import { IAM } from &quot;@hanzo/iam/browser&quot;;
const iam = new IAM({
serverUrl: &quot;https://iam.hanzo.ai&quot;,
clientId: &quot;hanzo-myspa&quot;,
redirectUri: `${location.origin}/auth/callback`,
});
await iam.signinRedirect(); // start
const token = await iam.handleCallback(); // on /auth/callback
const access = await iam.getValidAccessToken(); // auto-refresh</code></pre>
<pre><code class="lang-tsx">import { IamProvider, useIam } from &quot;@hanzo/iam/react&quot;;
&lt;IamProvider serverUrl=&quot;https://iam.hanzo.ai&quot; clientId=&quot;hanzo-myspa&quot;&gt;
&lt;App /&gt;
&lt;/IamProvider&gt;;</code></pre>
<p>The browser client uses PKCE <code>S256</code>, holds tokens in memory, and refreshes silently. Never persist access tokens in <code>localStorage</code>.</p>
<h4>Node / Express + Passport</h4>
<pre><code class="lang-ts">import passport from &quot;passport&quot;;
import { createIamPassportStrategy } from &quot;@hanzo/iam/passport&quot;;
passport.use(&quot;iam&quot;, createIamPassportStrategy({
serverUrl: &quot;https://iam.hanzo.ai&quot;,
clientId: &quot;hanzo-myservice&quot;,
clientSecret: process.env.IAM_CLIENT_SECRET!,
callbackUrl: &quot;https://myservice.hanzo.ai/v1/sso/oidc/callback&quot;,
}));</code></pre>
<h3>3. Application registration</h3>
<p>Every application is registered once per brand in IAM before it can authenticate.</p>
<ul><li><strong><code>client_id</code> naming</strong>: <code>&lt;org&gt;-&lt;app&gt;</code> (e.g. <code>hanzo-console</code>, <code>lux-wallet</code>, <code>zoo-research</code>). One ID per app per brand.</li><li><strong><code>redirectUris</code></strong>: MUST contain the <strong>exact</strong> callback the SDK/framework uses. There is no wildcard. Per framework:</li></ul>
<p>| Framework | Registered redirect URI | |-----------|-------------------------| | better-auth (<code>genericOAuth</code> + <code>iamProvider</code>) | <code>https://&lt;app-host&gt;/api/auth/oauth2/callback/hanzo</code> | | NextAuth / Auth.js | <code>https://&lt;app-host&gt;/api/auth/callback/iam</code> | | React SPA (<code>@hanzo/iam/browser</code>) | <code>https://&lt;app-host&gt;/auth/callback</code> | | Passport | <code>https://&lt;app-host&gt;/v1/sso/oidc/callback</code> |</p>
<p>The first two carry an <code>/api/</code> segment because better-auth and NextAuth mount their own handler there and the path is not ours to choose — it is a route on the <em>app&#x27;s</em> host, in a third-party framework&#x27;s namespace. The no-<code>/api/</code> rule (§4.4, §4.7) is about surfaces <strong>we</strong> serve; it is not weakened by a callback we merely register. A redirect URI that does not match the framework&#x27;s actual mount point byte for byte fails the flow, so this table records what the framework does, not what we would prefer.</p>
<ul><li><strong>Grant</strong>: Authorization Code + PKCE. Implicit grant is not used, and <code>implicit</code> is not a registered grant type on any application.</li><li><strong>Client secret</strong>: KMS-managed (HIP-0027, HIP-0136). Never in Git, init data, env files, or images.</li><li><strong>Superuser convention</strong>: no built-in admin — the seeded superuser <code>z@&lt;domain&gt;</code> is the only privileged account, and it is a member of the reserved <code>admin</code> org (HIP-0118). The password is the org&#x27;s, not the app&#x27;s.</li><li><strong>Machine identity</strong>: a service authenticates as itself with <code>client_credentials</code> and RFC 8707 <code>resource</code> naming the resource server it is calling — for example <code>resource=hanzo-egress</code> (HIP-0143). There is no service token, no shared secret and no per-app auth; a bearer that does not come from this endpoint is not an identity.</li></ul>
<h3>4. Forbidden anti-patterns</h3>
<p>These break in production and are not permitted under any circumstance:</p>
<ol><li><strong>Raw <code>better-auth</code> <code>genericOAuth({ discoveryUrl })</code></strong> — discovery resolves to the SPA catch-all HTML and the client dies with <code>content-type must be application/json</code>. Use <code>iamProvider()</code>, which pins explicit endpoints.</li><li><strong>Hand-rolled OAuth / PKCE / JWKS</strong> — use the SDK. Reimplementation gets <code>aud</code>, <code>S256</code>, or refresh rotation wrong.</li><li><strong>Any per-app OIDC path string</strong> — no application writes <code>/v1/iam/oauth/...</code> (or, worse, <code>/oauth/...</code>) itself. The path lives in <code>OIDC_PATHS</code> inside the SDK; applications pass only <code>serverUrl</code>.</li><li><strong>Legacy paths</strong> — <code>/oauth/<em></code>, <code>/api/login/oauth/</em></code>, anything <code>/api/</code>-prefixed. Gone. No backward compatibility.</li><li><strong>Non-empty <code>originFrontend</code></strong> in production — produces a split-origin discovery document that breaks strict clients.</li><li><strong>Per-app social OAuth clients</strong> — an app registering its own Google/GitHub (or Web3) OAuth client. Social providers are configured ONCE per network, org-level, and shared (§7). A per-app client re-creates the shared one N times and drifts.</li><li><strong><code>/api/</code> on the login entry point too</strong> — the IAM&#x27;s own login UI / portal Worker uses the native login API under <code>/v1/iam/*</code> (§6), never <code>/api/login</code>, <code>/api/get-app-login</code>, <code>/api/signup</code>. The &quot;no <code>/api/</code>&quot; rule is absolute, including the login entry point.</li><li><strong>&quot;Verb&quot; aliases / bespoke REST for a standardized capability</strong> — <code>get-users</code>, <code>get-user?id=</code>, <code>add-user</code>, <code>update-user</code>, <code>delete-user</code>, <code>get-organizations</code>, <code>get-records</code>, <code>issue-user-token</code>, <code>get-account</code>, <code>mint-user-keys</code>, and every other non-standard verb are <strong>gone</strong>, on iam and on every client. Each has an RFC that IS the surface: identity provisioning → <strong>SCIM 2.0</strong> (§8), delegated/on-behalf-of tokens → <strong>Token Exchange</strong> (§7), account claims → <strong>UserInfo</strong> (§1). A client that reaches for a verb is reaching for the wrong contract; there is no compat layer that will answer it.</li><li><strong>A duplicate spelling of a standard endpoint</strong> — one <code>token</code> endpoint, not <code>token</code> + <code>access_token</code>; one <code>userinfo</code>, not <code>userinfo</code> + <code>get-account</code>. An alias is two ways to do one thing; the standard path is the only one served.</li></ol>
<h3>5. Gotchas (call out explicitly)</h3>
<ul><li><strong>SPA catch-all</strong> — IAM returns a <code>200 text/html</code> page for ANY unregistered path. A wrong path is not a <code>404</code>; it is silent breakage. Clients MUST hit the exact <code>/v1/iam/*</code> paths. This is why the SDK centralizes paths and degrades discovery to hard-coded canonical values.</li><li><strong>Discovery self-consistency</strong> — issuer/authorize/token/userinfo/jwks share one origin (host-relative). Keep <code>originFrontend</code> empty in <code>app.prod.conf</code>.</li><li><strong><code>owner</code> is the tenant</strong> — the org slug. IAM emits <strong><code>owner</code></strong> (and the standard-name alias <strong><code>organization</code></strong>) in BOTH the OIDC userinfo response AND the JWT, in every token format, scope-independent — so a consumer reading either claim off either surface gets the tenant. Scope every data query to it. The gateway (HIP-0519) propagates it as <code>X-Org-Id</code>; backends behind the gateway trust that header and do not re-parse the JWT. A consumer that reads org from a non-standard field (e.g. a legacy <code>groups</code> claim) and finds nothing MUST fail closed, never silently fall back to a <code>&quot;default&quot;</code>/<code>&quot;personal&quot;</code> org — that is a tenant-isolation defect.</li></ul>
<h3>6. The login entry point — the AS&#x27;s own concern, not a client surface</h3>
<p>OAuth 2.0 / OIDC deliberately do <strong>not</strong> specify how the authorization server authenticates the end user (the credential-entry step). That is the AS&#x27;s internal concern. So the hosted login page (the per-brand portal at <code>hanzo.id</code>/<code>lux.id</code>/… and its Worker) has a small first-party API it — and ONLY it — calls, under the canonical <code>/v1/iam/*</code> prefix:</p>
<p>| Purpose | Path | |---------|------| | App/org resolution before login | <code>/v1/iam/get-app-login</code> | | Password login (mints the code) | <code>/v1/iam/login</code> | | Signup | <code>/v1/iam/signup</code> | | Verification code | <code>/v1/iam/send-verification-code</code> | | Logout | <code>/v1/iam/oauth/logout</code> (§1) |</p>
<p>This is NOT a client integration surface and NOT a set of &quot;verbs&quot; a client may call — it is the AS&#x27;s own login UI talking to the AS. <strong>Account claims are NOT here</strong>: there is no <code>get-account</code> and no second <code>userinfo</code> — every consumer (including the gateway admin-guard, HIP-0118) reads the standard <strong>OIDC UserInfo</strong> (<code>/v1/iam/oauth/userinfo</code>, §1), which carries <code>sub</code>, <code>owner</code>/<code>organization</code>, <code>email</code>, <code>email_verified</code>, and the <code>isAdmin</code> claim the SuperAdmin predicate derives from. One account contract, and it is the RFC one.</p>
<p>Same rule as §1: <code>/v1/iam/*</code> only — no <code>/api/</code>, anywhere, including the login Worker. <strong>Client apps use only the standard surface (§1) through the SDK</strong>; the login API is internal to the AS.</p>
<h3>7. Delegation / on-behalf-of — OAuth 2.0 Token Exchange (RFC 8693)</h3>
<p>A trusted first-party backend that must call a downstream API <strong>as</strong> an end user (the console BFF forwarding a request on the signed-in user&#x27;s behalf, the keyless AI proxy) obtains that token through <strong>RFC 8693 Token Exchange</strong> on the token endpoint — never a bespoke <code>issue-user-token</code> verb.</p>
<ul><li><code>grant_type=urn:ietf:params:oauth:grant-type:token-exchange</code>, <code>client_secret_basic</code> (confidential clients only), <code>subject_token</code> naming the target user (or a <code>requested_subject</code>), <code>requested_token_type=urn:ietf:params:oauth:token-type:access_token</code>, and <code>resource</code>/<code>audience</code> (RFC 8707) pinning the downstream resource server.</li><li>The issued token carries the <strong>target user&#x27;s</strong> subject + <code>owner</code> (so a resource server that scopes on the validated <code>owner</code> claim scopes to the user&#x27;s tenant), an <code>act</code> claim recording the acting client, and the requested <code>aud</code>. It is signed by the same trusted key the JWKS publishes — indistinguishable from a token the user obtained directly, which is the point.</li><li><strong>Two conditions gate it, both required</strong> (<code>internal/oidc/issuetoken.go</code>, <code>mintAllowed</code>): the acting application&#x27;s <strong>owning org</strong> must be a reserved platform signing owner (<code>admin</code>/<code>built-in</code>), AND its <code>client_id</code> must appear on <code>IAM_TOKEN_EXCHANGE_APPS</code>. The owner-pin is the decisive one. <code>client_id</code> and secret are body-supplied at registration, so a tenant could register an app whose <code>client_id</code> collides with a listed one and, on a backend whose duplicate-row order is unspecified, have its row resolve and its known secret authenticate — but its owner is its own tenant, never a signing owner, so it acts on nobody. An empty or unset list allows nothing.</li><li>Acting on behalf of a <strong>reserved-org (<code>admin</code>/<code>built-in</code>)</strong> subject requires the strictly narrower, separately granted <code>IAM_ADMIN_TOKEN_EXCHANGE_APPS</code>, under the same owner-pin (<code>adminMintAllowed</code>). A leaked general-exchange credential can therefore never reach a SuperAdmin identity (HIP-0118). Every exchange is audit-logged.</li><li><strong><code>IAM_KEY_MINT_ALLOWED_APPS</code> is a different authority and MUST NOT be conflated with these.</strong> It gates credential administration (<code>authz.CapKeyMint</code>) and is keyed on the application <strong>name</strong>, not the <code>client_id</code>, so an app permitted to exchange tokens is not thereby granted the credential-administration capability nor its reach across the entity registry. Two capabilities, two lists, two keys.</li></ul>
<h3>8. Identity provisioning — SCIM 2.0 (RFC 7644 / RFC 7643)</h3>
<p>Creating, reading, updating, and deleting identities is <strong>SCIM 2.0</strong> — the IETF standard for cross-domain identity management — under <code>/v1/iam/scim/v2/</code>. There are NO <code>get-users</code>/<code>add-user</code>/<code>get-organizations</code> verbs.</p>
<p>| Resource | Path | Maps to | |----------|------|---------| | Service provider config | <code>/v1/iam/scim/v2/ServiceProviderConfig</code> | supported features | | Schemas / resource types | <code>/v1/iam/scim/v2/{Schemas,ResourceTypes}</code> | discovery | | Users | <code>/v1/iam/scim/v2/Users</code> (+ <code>/{id}</code>) | the user entity | | Groups | <code>/v1/iam/scim/v2/Groups</code> (+ <code>/{id}</code>) | organizations, roles |</p>
<ul><li>Standard verbs are HTTP: <code>GET</code> (list with <code>filter</code>/<code>startIndex</code>/<code>count</code>, or by id), <code>POST</code> (create), <code>PUT</code>/<code>PATCH</code> (RFC 7644 §3.5.2 patch ops), <code>DELETE</code>. Lists return the SCIM <code>ListResponse</code> envelope (<code>totalResults</code>/<code>Resources</code>), not a <code>{status,data,data2}</code> one.</li><li>A User is the SCIM core schema (<code>urn:ietf:params:scim:schemas:core:2.0:User</code>) plus a Hanzo enterprise extension for <code>owner</code>/<code>isAdmin</code>/credential metadata. Passwords are write-only (<code>password</code> attribute in), never returned. Secrets never cross a SCIM response (the AS masks on read).</li><li>Tenant scope: a non-super caller&#x27;s SCIM view is pinned to its own <code>owner</code>; a SuperAdmin may <code>filter</code> across tenants. Same authorization model as every other surface — bearer-authenticated, owner-scoped, fail-closed.</li><li>Clients provision through the SDK&#x27;s SCIM client (or any conformant SCIM library); no client writes SCIM URLs by hand, same as §2/§3.</li></ul>
<h3>9. Social &amp; Web3 — one shared provider, never per-app</h3>
<p>Google, GitHub, and Web3 are configured <strong>once per network</strong> as org-level providers in IAM (<code>admin/provider-google</code>, <code>admin/provider-github</code>, …). Every app reuses them via a per-app <code>canSignIn</code> toggle — an application <strong>never</strong> registers its own social OAuth client (§4.6).</p>
<ul><li>The shared social OAuth client&#x27;s redirect URI is <strong>IAM&#x27;s own callback</strong> (<code>https://iam.&lt;brand&gt;/callback</code>); the provider hop happens inside IAM, not in the app. The app only ever sets <em>its own</em> <code>redirect_uri</code> (its <code>/auth/callback</code>).</li><li>An app selects a method with one knob: <code>startLogin({ provider })</code> adds <code>&amp;provider=&lt;name&gt;</code> to <code>/v1/iam/oauth/authorize</code>. Omit <code>provider</code> for the IAM login page (password + whatever it offers). <strong>One flow; the provider is a parameter, not a separate code path</strong> — adding a provider is a config entry plus a button, and every app inherits it.</li><li>Login buttons are presentation, wired through <code>@hanzo/ui</code> <code>&lt;SignIn providers={…}&gt;</code> to the SDK. A surface that lacks a working button has it <em>disabled in config</em> — it is never <em>deleted from code</em>, because the shared provider is always available.</li></ul>
<h2>Conformance status</h2>
<p>The prohibitions in §Anti-patterns are <strong>met by the deployment.</strong> Measured against <code>https://hanzo.id</code> on 2026-09-09; unauthenticated probes, so a <code>401</code> would mean the route still exists and demands auth, and <code>410 Gone</code> means it was removed on purpose and the server says what replaced it:</p>
<p>| Surface | This HIP says | Production returns | |---|---|---| | <code>/v1/iam/get-users</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/users&quot;]}</code> | | <code>/v1/iam/get-user</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/users&quot;,&quot;/v1/iam/keys/principal&quot;]}</code> | | <code>/v1/iam/add-user</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/users&quot;]}</code> | | <code>/v1/iam/get-organizations</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/organizations&quot;]}</code> | | <code>/v1/iam/get-application</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/applications&quot;]}</code> | | <code>/v1/iam/issue-user-token</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/tokens/issue&quot;]}</code> | | <code>/v1/iam/get-records</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/audit-logs&quot;]}</code> | | <code>/v1/iam/get-account</code> | gone | <code>410</code> → <code>{&quot;successor&quot;:[&quot;/v1/iam/account&quot;]}</code> |</p>
<p>The two further deviations are also closed. <code>/v1/iam/oauth/access_token</code> returns <code>404</code>; the standard <code>/v1/iam/oauth/token</code> is the only spelling, and it answers a <code>POST</code> with <code>400</code> on an empty body rather than a <code>200</code> carrying an error envelope. The <code>get-account</code> shape that returned <code>200</code> with <code>{&quot;status&quot;:&quot;error&quot;}</code> is gone with the rest.</p>
<p><code>410</code> rather than <code>404</code> is the stronger result, and the retirement order in this section is why it was reachable. A <code>404</code> says only that nothing is there; <code>410</code> with a <code>successor</code> says the route was removed deliberately and names the RFC route that replaced it, so a client still on an alias gets told where to go instead of guessing. The order held: callers moved to the native routes first, the aliases went second, and no deletion was an outage.</p>
<p>The standard surfaces this HIP mandates remain present and correct (<code>/v1/iam/scim/v2/Users</code> and <code>/v1/iam/scim/v2/ServiceProviderConfig</code> answer <code>401</code> as <code>application/json</code>; <code>/v1/iam/.well-known/jwks</code> serves an RS256 key set; <code>/v1/iam/oauth/{authorize,token,introspect}</code> are live routes, not the SPA; discovery is single-origin on <code>https://hanzo.id</code> and advertises RFC 8693 token-exchange and device_code). One surface, one spelling — which is what this HIP asked for.</p>
<p>The catch-all still discriminates, and that is how these probes are read: the uncanonical <code>/scim/v2/Users</code> returns <code>200 text/html</code>, the canonical <code>/v1/iam/scim/v2/Users</code> returns <code>401 application/json</code>. Content type, not status, is the test.</p>
<h2>Security Considerations</h2>
<ul><li><strong>PKCE <code>S256</code> mandatory</strong> for all flows. Authorization-code interception is the most common OAuth attack; PKCE eliminates it.</li><li><strong>Signature + claim validation</strong> — <code>validateToken</code> verifies the JWKS signature and <code>iss</code>/<code>aud</code>/<code>exp</code>. Never accept a token without these checks.</li><li><strong>Token storage</strong> — in-memory or httpOnly cookies. Never <code>localStorage</code>.</li><li><strong>Confidential-client secrets</strong> — KMS only (HIP-0027). <code>client_secret_basic</code> over TLS.</li><li><strong>Refresh rotation</strong> — handled by the SDK; refresh tokens rotate on use and the previous token is invalidated.</li><li><strong>TLS everywhere</strong> — IAM rejects plaintext. The gateway and ingress (HIP-0519, HIP-0068) terminate and re-encrypt.</li></ul>
<h2>References</h2>
<ol><li><a href="./hip-0026-identity-access-management-standard.md">HIP-0026: Identity &amp; Access Management Standard</a> — the IAM server</li><li><a href="./hip-0519-one-identity-boundary.md">HIP-0519: One Identity Boundary</a> — JWT validation + <code>X-Org-Id</code> minted once at the edge</li><li><a href="./hip-0068-ingress-standard.md">HIP-0068: Ingress Standard</a> — edge TLS and routing</li><li><a href="./hip-0027-secrets-management-standard.md">HIP-0027: Secrets Management Standard</a> — KMS-managed client secrets</li><li><a href="./hip-0134-one-process-one-socket-one-identity.md">HIP-0134: One Process, One Socket, One Identity</a> — how IAM fits the estate</li><li><a href="./hip-0118-superadmin-and-tenant-isolation-model.md">HIP-0118: SuperAdmin &amp; Tenant Isolation Model</a> — the reserved-org predicate <code>IAM_ADMIN_TOKEN_EXCHANGE_APPS</code> defends</li><li><a href="./hip-0136-one-secret-one-path.md">HIP-0136: One Secret, One Path</a> — where a client secret is addressed</li><li><a href="./hip-0143-egress-outbound-trust-boundary.md">HIP-0143: Egress — The Outbound Trust Boundary</a> — the machine identity a caller presents in order to spend</li><li><a href="https://github.com/hanzo-js/iam"><code>@hanzo/iam</code></a> — the SDK; <code>src/paths.ts</code> is the canonical path source</li><li>Standards this surface implements (the wire contract, in full):</li></ol>
<ul><li><a href="https://datatracker.ietf.org/doc/html/rfc6749">RFC 6749</a> OAuth 2.0 — authorize, token (authorization_code / refresh_token / client_credentials / password grants)</li><li><a href="https://datatracker.ietf.org/doc/html/rfc7636">RFC 7636</a> PKCE <code>S256</code></li><li><a href="https://datatracker.ietf.org/doc/html/rfc7517">RFC 7517</a> JWK / JWKS</li><li><a href="https://datatracker.ietf.org/doc/html/rfc7662">RFC 7662</a> Token Introspection</li><li><a href="https://datatracker.ietf.org/doc/html/rfc7009">RFC 7009</a> Token Revocation</li><li><a href="https://datatracker.ietf.org/doc/html/rfc8414">RFC 8414</a> Authorization Server Metadata</li><li><a href="https://datatracker.ietf.org/doc/html/rfc8693">RFC 8693</a> OAuth 2.0 Token Exchange — delegation / on-behalf-of (replaces <code>issue-user-token</code>)</li><li><a href="https://datatracker.ietf.org/doc/html/rfc8707">RFC 8707</a> Resource Indicators (<code>resource</code>/<code>audience</code>)</li><li><a href="https://datatracker.ietf.org/doc/html/rfc8628">RFC 8628</a> Device Authorization Grant (optional, for input-constrained clients)</li><li><a href="https://datatracker.ietf.org/doc/html/rfc7644">RFC 7644</a> SCIM 2.0 Protocol + <a href="https://datatracker.ietf.org/doc/html/rfc7643">RFC 7643</a> SCIM Core Schema — identity provisioning (replaces the <code>get-users</code>/<code>add-user</code> verbs)</li><li><a href="https://openid.net/specs/openid-connect-core-1_0.html">OpenID Connect Core 1.0</a> + <a href="https://openid.net/specs/openid-connect-discovery-1_0.html">Discovery 1.0</a> — id_token, UserInfo, discovery, RP-initiated logout</li></ul>
<h2>Copyright</h2>
<p>Copyright and related rights waived via <a href="https://creativecommons.org/publicdomain/zero/1.0/">CC0</a>.</p>
<footer>
<div class="fmap">
<div><b>Build</b>
<a href="https://hanzo.app">hanzo.app</a> app builder
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
<div><b>Run</b>
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
<div><b>Account</b>
<a href="https://hanzo.id">hanzo.id</a> sign in
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
<div><b>Company</b>
<a href="https://hanzo.ai">hanzo.ai</a> canonical
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
</div>
<div class="fend"><a href="/hip-0111.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>