@plitzi/sdk-server 0.32.12 → 0.32.14

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @plitzi/sdk-server
 
+## 0.32.14
+
+### Patch Changes
+
+- v0.32.14
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.32.14
+  - @plitzi/sdk-schema@0.32.14
+  - @plitzi/sdk-shared@0.32.14
+
+## 0.32.13
+
+### Patch Changes
+
+- v0.32.13
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.32.13
+  - @plitzi/sdk-schema@0.32.13
+  - @plitzi/sdk-shared@0.32.13
+
 ## 0.32.12
 
 ### Patch Changes

package/dist/core/services/oauth.js

@@ -1,7 +1,9 @@
 import { readRawBody } from "../requestParser.js";
 import { authorizationServerMetadata, protectedResourceMetadata } from "../../modules/oauth/metadata.js";
+import { getAccess } from "../../modules/oauth/records.js";
 import { sendErrorJson, sendJson } from "../../modules/oauth/respond.js";
 import { handleAuthorizeStart, handleAuthorizeSubmit } from "../../modules/oauth/authorize.js";
+import { bearerOf, sendChallenge } from "../../modules/oauth/challenge.js";
 import { handleRegister } from "../../modules/oauth/register.js";
 import { handleToken } from "../../modules/oauth/token.js";
 //#region src/core/services/oauth.ts
@@ -67,5 +69,48 @@ var oauthStage = async (ctx) => {
 	sendErrorJson(res, 405, "invalid_request", `${method} is not allowed on ${path}.`);
 	return true;
 };
+var CHALLENGE_DESCRIPTIONS = {
+	"no-credential": "Authorization is required to use this server.",
+	"unknown-credential": "The access token is invalid, expired or revoked.",
+	"store-unreachable": "The access token could not be verified right now.",
+	"adapter-failed": "The access token could not be verified right now."
+};
+var challengeReason = async (oauth, ctx, token) => {
+	if (!token) return "no-credential";
+	try {
+		const record = await getAccess(oauth.adapters.store, token);
+		if (record) {
+			const credential = record.credential ?? token;
+			ctx.req.headers["x-access-token"] = credential;
+			ctx.req.headers.authorization = `Bearer ${credential}`;
+			return;
+		}
+	} catch {
+		return "store-unreachable";
+	}
+	try {
+		return await ctx.config.adapters.getSpaceId?.(ctx.req) === void 0 ? "unknown-credential" : void 0;
+	} catch {
+		return "adapter-failed";
+	}
+};
+/** The protected-resource half of OAuth: an MCP call that presents no bearer this server can verify is refused
+*  with RFC 6750's challenge instead of being served the anonymous surface. That 401 is the whole handshake — it
+*  is how a host learns the server needs authorization, where its metadata lives and which scopes to ask for, and
+*  a 200 tells it none of that. Only the JSON-RPC POST is guarded: the CORS preflight, the GET 405 and the
+*  discovery probes carry no credential and must keep answering as they do.
+*
+*  Mounted only when `oauth` is configured. A deployment that configures none keeps the open server it had, where
+*  the whole public surface — handshake, listings, the guide, plitzi_render — answers without a token; with OAuth
+*  on, the grant that carries no space is what covers that same ground. */
+var oauthGuardStage = async (ctx) => {
+	const { oauth } = ctx.config;
+	if (!oauth || ctx.req.method !== "POST") return false;
+	const reason = await challengeReason(oauth, ctx, bearerOf(ctx.req));
+	if (!reason) return false;
+	ctx.operation = `oauth-challenge:${reason}`;
+	sendChallenge(oauth, ctx.req, ctx.res, CHALLENGE_DESCRIPTIONS[reason]);
+	return true;
+};
 //#endregion
-export { oauthStage };
+export { oauthGuardStage, oauthStage };

package/dist/core/services/registry.js

@@ -1,5 +1,5 @@
 import { mcpOnlyStage, mcpStage } from "./mcp.js";
-import { oauthStage } from "./oauth.js";
+import { oauthGuardStage, oauthStage } from "./oauth.js";
 import { previewStage } from "./preview.js";
 import { rscStage } from "./rsc.js";
 import { notFoundStage, ssrStage } from "./ssr.js";
@@ -30,6 +30,7 @@ var buildMCPPipeline = () => [
 	healthStage,
 	configStaticStage,
 	oauthStage,
+	oauthGuardStage,
 	mcpOnlyStage
 ];
 //#endregion

package/dist/modules/mcp/server.js

@@ -43,7 +43,7 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger }) =>
 	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: "0.32.12"
+		version: "0.32.14"
 	}, { instructions: serverInstructions });
 	registerResources(server, getSpace, MCP_ENV, log);
 	registerApps(server);

package/dist/modules/oauth/authorize.js

@@ -6,6 +6,15 @@ import { dropPending, getClient, getPending, putCode, putPending } from "./recor
 import { redirectWithCode, redirectWithError, sendErrorPage, sendHtml } from "./respond.js";
 //#region src/modules/oauth/authorize.ts
 var DEFAULT_CODE_TTL_SECONDS = 60;
+var DEFAULT_GUEST_LABEL = "Continue without an account";
+var DEFAULT_GUEST_USER = {
+	id: "guest",
+	label: "Guest"
+};
+var guestView = (guest) => ({
+	label: guest.label ?? DEFAULT_GUEST_LABEL,
+	description: guest.target.description
+});
 var hiddenFieldsFor = (request, pendingId) => {
 	const hidden = {
 		client_id: request.clientId,
@@ -57,8 +66,8 @@ var resolveRequest = async (config, res, params) => {
 };
 /** Consent granted: mint the bearer now, park it behind a one-shot code and send the browser back. Minting here
 *  rather than at redemption keeps a failure the user can act on — no space, revoked access — on this screen. */
-var completeGrant = async (config, res, request, pending, target) => {
-	const issued = await config.adapters.issueToken(pending.user, target);
+var completeGrant = async (config, res, request, user, target) => {
+	const issued = await config.adapters.issueToken(user, target);
 	if (!issued) {
 		redirectWithError(res, request.redirectUri, "access_denied", "The account may not grant access to this resource.", request.state);
 		return;
@@ -71,7 +80,7 @@ var completeGrant = async (config, res, request, pending, target) => {
 		token: issued.token,
 		expiresInSeconds: issued.expiresInSeconds,
 		scope: request.scope,
-		user: pending.user,
+		user,
 		target
 	}, config.codeTtlSeconds ?? DEFAULT_CODE_TTL_SECONDS);
 	redirectWithCode(res, request.redirectUri, code, request.state);
@@ -85,6 +94,7 @@ var handleAuthorizeStart = async (config, res, params) => {
 		action: AUTHORIZE_PATH,
 		hidden: hiddenFieldsFor(request),
 		targets: [],
+		guest: config.guest ? guestView(config.guest) : void 0,
 		branding: config.branding ?? {}
 	});
 };
@@ -115,7 +125,12 @@ var handleAuthorizeSubmit = async (config, res, params) => {
 			return;
 		}
 		await dropPending(config.adapters.store, pendingId);
-		await completeGrant(config, res, request, pending, chosen);
+		await completeGrant(config, res, request, pending.user, chosen);
+		return;
+	}
+	const { guest } = config;
+	if (guest && optionalField(params, "guest")) {
+		await completeGrant(config, res, request, guest.user ?? DEFAULT_GUEST_USER, guest.target);
 		return;
 	}
 	const user = await config.adapters.authenticate({
@@ -128,6 +143,7 @@ var handleAuthorizeSubmit = async (config, res, params) => {
 			action: AUTHORIZE_PATH,
 			hidden: hiddenFieldsFor(request),
 			targets: [],
+			guest: guest ? guestView(guest) : void 0,
 			error: "Those credentials did not match an account.",
 			branding: config.branding ?? {}
 		});

package/dist/modules/oauth/challenge.js

@@ -0,0 +1,33 @@
+import { resourceMetadataUrl, scopesOf } from "./metadata.js";
+import { sendJson } from "./respond.js";
+//#region src/modules/oauth/challenge.ts
+/** The credential on an MCP request. `Authorization: Bearer` is what RFC 6750 defines and what a remote host
+*  sends; `x-access-token` is the platform's own header, which the builder and the CLI already use — a request
+*  carrying either presents a credential, and the same verification decides whether it is a good one. */
+var bearerOf = (req) => {
+	const header = req.headers["x-access-token"] ?? req.headers.authorization ?? "";
+	return (Array.isArray(header) ? header[0] ?? "" : header).replace(/^Bearer\s+/i, "").trim();
+};
+var parameter = (name, value) => `${name}="${value.replace(/"/gu, "")}"`;
+/** RFC 6750 §3 — the answer to an MCP request that presents no usable credential, and the only thing that starts
+*  an authorization flow: a host runs OAuth off a 401 whose `WWW-Authenticate` names the resource metadata, and
+*  IGNORES the header on a 200. Answering such a request with the anonymous surface instead is what leaves a
+*  connector unable to attach the grant it just completed — the flow succeeds and the host still reports that
+*  authorization failed. `scope` states what to ask for, so consent is not widened to everything advertised. */
+var sendChallenge = (config, req, res, description) => {
+	const params = [
+		parameter("error", "invalid_token"),
+		parameter("error_description", description),
+		parameter("resource_metadata", resourceMetadataUrl(config, req)),
+		parameter("scope", scopesOf(config).join(" "))
+	];
+	res.setHeader("WWW-Authenticate", `Bearer ${params.join(", ")}`);
+	res.setHeader("Access-Control-Allow-Origin", "*");
+	res.setHeader("Access-Control-Expose-Headers", "WWW-Authenticate");
+	sendJson(res, 401, {
+		error: "invalid_token",
+		error_description: description
+	});
+};
+//#endregion
+export { bearerOf, sendChallenge };

package/dist/modules/oauth/consentPage.js

@@ -35,16 +35,23 @@ var STYLES = `
   ul.targets span { color: var(--muted); font-size: 13px; }
   button { width: 100%; padding: 11px 16px; border: 0; border-radius: 8px; background: var(--accent);
     color: #fff; font: inherit; font-weight: 500; cursor: pointer; }
+  button.guest { margin-top: 10px; background: transparent; color: var(--accent);
+    border: 1px solid var(--line); }
   p.error { margin: 0 0 16px; padding: 10px 12px; border-radius: 8px; color: var(--danger);
     border: 1px solid currentColor; font-size: 14px; }
+  p.note { margin: 10px 0 0; color: var(--muted); font-size: 13px; text-align: center; }
 `;
 var hiddenFields = (hidden) => Object.entries(hidden).map(([name, value]) => `<input type="hidden" name="${escapeHtml(name)}" value="${escapeHtml(value)}">`).join("\n      ");
-var credentialsFields = () => `<label for="username">Email or username</label>
+var guestButton = (guest) => {
+	const note = guest.description ? `\n      <p class="note">${escapeHtml(guest.description)}</p>` : "";
+	return `\n      <button class="guest" type="submit" name="guest" value="1" formnovalidate>${escapeHtml(guest.label)}</button>${note}`;
+};
+var credentialsFields = (view) => `<label for="username">Email or username</label>
       <input id="username" name="username" type="text" autocomplete="username" autocapitalize="none"
         spellcheck="false" required autofocus>
       <label for="password">Password</label>
       <input id="password" name="password" type="password" autocomplete="current-password" required>
-      <button type="submit">Sign in</button>`;
+      <button type="submit">Sign in</button>${view.guest ? guestButton(view.guest) : ""}`;
 var targetFields = (view) => {
 	return `<ul class="targets">
         ${view.targets.map((target, index) => {
@@ -82,7 +89,7 @@ var renderConsentPage = (view) => {
     ${error}
     <form method="post" action="${escapeHtml(view.action)}">
       ${hiddenFields(view.hidden)}
-      ${view.step === "credentials" ? credentialsFields() : targetFields(view)}
+      ${view.step === "credentials" ? credentialsFields(view) : targetFields(view)}
     </form>
   </main>
 </body>

package/dist/modules/oauth/metadata.js

@@ -11,22 +11,35 @@ var DEFAULT_SCOPES = ["plitzi"];
 *  deployment correct across its dev, staging and production hosts without per-environment config. */
 var issuerOf = (config, req) => config.issuer ?? requestOrigin(req);
 var scopesOf = (config) => config.scopes ?? DEFAULT_SCOPES;
+var canonicalPath = (path) => path.replace(/\/+$/, "");
+/** Where the challenge points a host, for an MCP endpoint served at `req.path`. RFC 9728 §3.1 appends the
+*  resource's own path to the well-known path, and a host that reads the document back expects its `resource` to
+*  name the URL it was configured with — so a server mounted at /mcp must be pointed at the suffixed document,
+*  not the bare one. */
+var resourceMetadataUrl = (config, req) => `${issuerOf(config, req)}${PROTECTED_RESOURCE_PATH}${canonicalPath(req.path)}`;
 /** RFC 9728. The document Claude Desktop asks for FIRST, and the one whose absence ends the flow before anything
-*  else is tried — a 404 here is what a host reports as `mcp_auth_start_failed`. */
+*  else is tried — a 404 here is what a host reports as `mcp_auth_start_failed`.
+*
+*  `resource` echoes the path the document was asked for: Claude requires it to match the server URL the user
+*  typed, path included, and a dedicated MCP server answers JSON-RPC on every path — so `/.well-known/…/mcp`
+*  describes `https://host/mcp` while the bare path describes the origin. */
 var protectedResourceMetadata = (config, req) => {
 	const issuer = issuerOf(config, req);
 	return {
-		resource: issuer,
+		resource: `${issuer}${canonicalPath(req.path.slice(37))}`,
 		authorization_servers: [issuer],
 		scopes_supported: scopesOf(config),
 		bearer_methods_supported: ["header"]
 	};
 };
 /** RFC 8414. Public clients with PKCE only: a desktop host stores no secret, so `none` is the sole endpoint auth
-*  method and S256 the sole challenge method. */
+*  method and S256 the sole challenge method. `offline_access` is advertised whenever refresh grants are issued,
+*  which is the signal a host looks for before asking for one. */
 var authorizationServerMetadata = (config, req) => {
 	const issuer = issuerOf(config, req);
-	const grantTypes = config.refreshTtlSeconds === 0 ? ["authorization_code"] : ["authorization_code", "refresh_token"];
+	const refreshes = config.refreshTtlSeconds !== 0;
+	const grantTypes = refreshes ? ["authorization_code", "refresh_token"] : ["authorization_code"];
+	const scopes = refreshes ? [...scopesOf(config), "offline_access"] : scopesOf(config);
 	return {
 		issuer,
 		authorization_endpoint: `${issuer}${AUTHORIZE_PATH}`,
@@ -36,8 +49,8 @@ var authorizationServerMetadata = (config, req) => {
 		grant_types_supported: grantTypes,
 		code_challenge_methods_supported: ["S256"],
 		token_endpoint_auth_methods_supported: ["none"],
-		scopes_supported: scopesOf(config)
+		scopes_supported: scopes
 	};
 };
 //#endregion
-export { AUTHORIZATION_SERVER_PATH, AUTHORIZE_PATH, PROTECTED_RESOURCE_PATH, REGISTER_PATH, TOKEN_PATH, authorizationServerMetadata, issuerOf, protectedResourceMetadata, scopesOf };
+export { AUTHORIZATION_SERVER_PATH, AUTHORIZE_PATH, PROTECTED_RESOURCE_PATH, REGISTER_PATH, TOKEN_PATH, authorizationServerMetadata, issuerOf, protectedResourceMetadata, resourceMetadataUrl, scopesOf };

package/dist/modules/oauth/records.js

@@ -31,5 +31,7 @@ var getRefresh = (store, token) => readJson(store, "refresh", token);
 var dropRefresh = async (store, token) => {
 	await store.drop(keyOf("refresh", token));
 };
+var putAccess = (store, token, record, ttlSeconds) => writeJson(store, "access", token, record, ttlSeconds);
+var getAccess = (store, token) => readJson(store, "access", token);
 //#endregion
-export { dropCode, dropPending, dropRefresh, getClient, getCode, getPending, getRefresh, putClient, putCode, putPending, putRefresh };
+export { dropCode, dropPending, dropRefresh, getAccess, getClient, getCode, getPending, getRefresh, putAccess, putClient, putCode, putPending, putRefresh };

package/dist/modules/oauth/token.js

@@ -1,18 +1,26 @@
 import { scopesOf } from "./metadata.js";
 import { field, optionalField } from "./params.js";
 import { randomId, verifyChallenge } from "./pkce.js";
-import { dropCode, dropRefresh, getCode, getRefresh, putRefresh } from "./records.js";
+import { dropCode, dropRefresh, getCode, getRefresh, putAccess, putRefresh } from "./records.js";
 import { sendErrorJson, sendJson } from "./respond.js";
 //#region src/modules/oauth/token.ts
 var DEFAULT_REFRESH_TTL_SECONDS = 3600 * 24 * 30;
+var DEFAULT_ACCESS_TTL_SECONDS = 3600 * 24 * 30;
 var refreshTtlOf = (config) => config.refreshTtlSeconds ?? DEFAULT_REFRESH_TTL_SECONDS;
 var scopeOf = (config, requested) => requested ?? scopesOf(config).join(" ");
 /** The token response, plus a rotated refresh grant when refresh is enabled. Rotation is unconditional: a refresh
 *  token is a long-lived credential, so the one just used never stays valid. */
-var sendTokens = async (config, res, token, expiresInSeconds, grant) => {
+var sendTokens = async (config, res, credential, expiresInSeconds, grant) => {
 	const ttl = refreshTtlOf(config);
+	const bearer = randomId();
+	await putAccess(config.adapters.store, bearer, {
+		credential,
+		clientId: grant.clientId,
+		user: grant.user,
+		target: grant.target
+	}, Math.max(expiresInSeconds ?? DEFAULT_ACCESS_TTL_SECONDS, 1));
 	const body = {
-		access_token: token,
+		access_token: bearer,
 		token_type: "Bearer",
 		scope: scopeOf(config, grant.scope)
 	};

package/dist/src/core/services/oauth.d.ts

@@ -6,3 +6,13 @@ import { Stage } from '../http/types';
  *  It sits before the MCP stage because that one answers every path on a dedicated MCP server — these endpoints
  *  would otherwise be swallowed by the JSON-RPC transport, which is exactly the 406 a host hits on /register. */
 export declare const oauthStage: Stage;
+/** The protected-resource half of OAuth: an MCP call that presents no bearer this server can verify is refused
+ *  with RFC 6750's challenge instead of being served the anonymous surface. That 401 is the whole handshake — it
+ *  is how a host learns the server needs authorization, where its metadata lives and which scopes to ask for, and
+ *  a 200 tells it none of that. Only the JSON-RPC POST is guarded: the CORS preflight, the GET 405 and the
+ *  discovery probes carry no credential and must keep answering as they do.
+ *
+ *  Mounted only when `oauth` is configured. A deployment that configures none keeps the open server it had, where
+ *  the whole public surface — handshake, listings, the guide, plitzi_render — answers without a token; with OAuth
+ *  on, the grant that carries no space is what covers that same ground. */
+export declare const oauthGuardStage: Stage;

package/dist/src/modules/mcp/e2e/oauthConnector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/oauth/challenge.d.ts

@@ -0,0 +1,11 @@
+import { OAuthConfig, SSRRequest, SSRResponseHelpers } from '@plitzi/sdk-shared';
+/** The credential on an MCP request. `Authorization: Bearer` is what RFC 6750 defines and what a remote host
+ *  sends; `x-access-token` is the platform's own header, which the builder and the CLI already use — a request
+ *  carrying either presents a credential, and the same verification decides whether it is a good one. */
+export declare const bearerOf: (req: SSRRequest) => string;
+/** RFC 6750 §3 — the answer to an MCP request that presents no usable credential, and the only thing that starts
+ *  an authorization flow: a host runs OAuth off a 401 whose `WWW-Authenticate` names the resource metadata, and
+ *  IGNORES the header on a 200. Answering such a request with the anonymous surface instead is what leaves a
+ *  connector unable to attach the grant it just completed — the flow succeeds and the host still reports that
+ *  authorization failed. `scope` states what to ask for, so consent is not widened to everything advertised. */
+export declare const sendChallenge: (config: OAuthConfig, req: SSRRequest, res: SSRResponseHelpers, description: string) => void;

package/dist/src/modules/oauth/metadata.d.ts

@@ -9,9 +9,19 @@ export declare const AUTHORIZATION_SERVER_PATH = "/.well-known/oauth-authorizati
  *  deployment correct across its dev, staging and production hosts without per-environment config. */
 export declare const issuerOf: (config: OAuthConfig, req: SSRRequest) => string;
 export declare const scopesOf: (config: OAuthConfig) => string[];
+/** Where the challenge points a host, for an MCP endpoint served at `req.path`. RFC 9728 §3.1 appends the
+ *  resource's own path to the well-known path, and a host that reads the document back expects its `resource` to
+ *  name the URL it was configured with — so a server mounted at /mcp must be pointed at the suffixed document,
+ *  not the bare one. */
+export declare const resourceMetadataUrl: (config: OAuthConfig, req: SSRRequest) => string;
 /** RFC 9728. The document Claude Desktop asks for FIRST, and the one whose absence ends the flow before anything
- *  else is tried — a 404 here is what a host reports as `mcp_auth_start_failed`. */
+ *  else is tried — a 404 here is what a host reports as `mcp_auth_start_failed`.
+ *
+ *  `resource` echoes the path the document was asked for: Claude requires it to match the server URL the user
+ *  typed, path included, and a dedicated MCP server answers JSON-RPC on every path — so `/.well-known/…/mcp`
+ *  describes `https://host/mcp` while the bare path describes the origin. */
 export declare const protectedResourceMetadata: (config: OAuthConfig, req: SSRRequest) => Record<string, unknown>;
 /** RFC 8414. Public clients with PKCE only: a desktop host stores no secret, so `none` is the sole endpoint auth
- *  method and S256 the sole challenge method. */
+ *  method and S256 the sole challenge method. `offline_access` is advertised whenever refresh grants are issued,
+ *  which is the signal a host looks for before asking for one. */
 export declare const authorizationServerMetadata: (config: OAuthConfig, req: SSRRequest) => Record<string, unknown>;

package/dist/src/modules/oauth/records.d.ts

@@ -36,6 +36,20 @@ export type RefreshRecord = {
     user: OAuthUser;
     target: OAuthGrantTarget;
 };
+/** A bearer this server handed out. The token a client holds is an opaque handle minted here, and this record is
+ *  what it stands for — including `credential`, the thing the deployment's own adapters understand, which never
+ *  leaves the server: a platform token is usually good against more than the MCP endpoint, and a remote host has
+ *  no business holding one. The record expires with the bearer, which is what turns an expired one into the 401 a
+ *  host answers by refreshing; dropping it early revokes the bearer outright. */
+export type AccessRecord = {
+    /** What {@link OAuthAdapters.issueToken} returned — swapped back onto the request once the bearer checks out.
+     *  Absent only in a record written before the bearer and the credential were separate things, where the bearer
+     *  WAS the credential: a live connector must survive that upgrade, so the reader falls back to the token itself. */
+    credential?: string;
+    clientId: string;
+    user: OAuthUser;
+    target: OAuthGrantTarget;
+};
 export declare const putClient: (store: OAuthStore, client: ClientRecord) => Promise<void>;
 export declare const getClient: (store: OAuthStore, clientId: string) => Promise<ClientRecord | undefined>;
 export declare const putPending: (store: OAuthStore, id: string, pending: PendingRecord) => Promise<void>;
@@ -47,3 +61,5 @@ export declare const dropCode: (store: OAuthStore, code: string) => Promise<void
 export declare const putRefresh: (store: OAuthStore, token: string, record: RefreshRecord, ttlSeconds: number) => Promise<void>;
 export declare const getRefresh: (store: OAuthStore, token: string) => Promise<RefreshRecord | undefined>;
 export declare const dropRefresh: (store: OAuthStore, token: string) => Promise<void>;
+export declare const putAccess: (store: OAuthStore, token: string, record: AccessRecord, ttlSeconds: number) => Promise<void>;
+export declare const getAccess: (store: OAuthStore, token: string) => Promise<AccessRecord | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.32.12",
+  "version": "0.32.14",
   "license": "AGPL-3.0",
   "files": [
     "dist"
@@ -29,9 +29,9 @@
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^1.7.5",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@plitzi/plitzi-sdk": "0.32.12",
-    "@plitzi/sdk-schema": "0.32.12",
-    "@plitzi/sdk-shared": "0.32.12",
+    "@plitzi/plitzi-sdk": "0.32.14",
+    "@plitzi/sdk-schema": "0.32.14",
+    "@plitzi/sdk-shared": "0.32.14",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.1",
     "zod": "^4.4.3"