@plitzi/sdk-server 0.32.25 → 0.33.0

package/dist/modules/ai/AIEngine.js

@@ -1,120 +0,0 @@
-import { firstText, toolResponseErr } from "./toolkit.js";
-//#region src/modules/ai/AIEngine.ts
-var AIEngine = class {
-	mode;
-	callbacks;
-	toolsAvailables = /* @__PURE__ */ new Map();
-	toolsAvailablesMap = /* @__PURE__ */ new Map();
-	ctx;
-	constructor(mode, callbacks, ctx) {
-		this.mode = mode;
-		this.callbacks = callbacks;
-		this.ctx = {
-			...ctx,
-			mode: mode || "plan"
-		};
-	}
-	readResource = (name, uri) => {
-		this.callbacks.onResourceRead?.(name, uri);
-	};
-	setToolsAvailables = (tools) => {
-		this.toolsAvailables = new Map(tools.map((t) => [t.name, t]));
-		this.toolsAvailablesMap = new Map(tools.map((t) => [t.name, t.definition.allowedModes]));
-	};
-	can = (name) => {
-		if (!this.mode || !this.toolsAvailablesMap.has(name)) return false;
-		const allowedModes = this.toolsAvailablesMap.get(name);
-		return !allowedModes || allowedModes.includes(this.mode);
-	};
-	before = async (name, args) => {
-		this.callbacks.onBeforeTool?.(name, args);
-		if (!this.toolsAvailables.has(name)) {
-			this.callbacks.onLog?.("error", `tool rejected: '${name}' has no definition — possible security violation`);
-			await this.after(name, args, toolResponseErr(`Tool '${name}' is not defined and cannot be executed`));
-			return false;
-		}
-		if (!this.can(name)) {
-			this.callbacks.onLog?.("info", `tool blocked: '${name}' is not permitted in ${this.mode} mode`);
-			await this.after(name, args, toolResponseErr(`Tool '${name}' is not permitted in ${this.mode} mode`));
-			return false;
-		}
-		return true;
-	};
-	after = (name, args, result) => {
-		let resultParsed;
-		if (result.data !== void 0) resultParsed = result.data;
-		else try {
-			resultParsed = JSON.parse(firstText(result.content) ?? "");
-		} catch {}
-		if (result.isError) this.callbacks.onToolError?.({
-			name,
-			args,
-			result: resultParsed ?? { error: firstText(result.content) ?? "Tool failed" }
-		});
-		else this.callbacks.onToolSuccess?.({
-			name,
-			args,
-			result: resultParsed
-		});
-		return Promise.resolve();
-	};
-	validateToolInput = (name, args) => {
-		const tool = this.toolsAvailables.get(name);
-		if (!tool || !tool.mcpDefinition.inputSchema) return {
-			success: true,
-			data: args
-		};
-		const parsed = tool.mcpDefinition.inputSchema.safeParse(args);
-		if (!parsed.success) return {
-			success: false,
-			error: parsed.error.message
-		};
-		return {
-			success: true,
-			data: parsed.data
-		};
-	};
-	validateToolOutput = (name, result) => {
-		const tool = this.toolsAvailables.get(name);
-		if (!tool || !tool.mcpDefinition.outputSchema || result.isError) return;
-		if (result.data === void 0) return;
-		const parsed = tool.mcpDefinition.outputSchema.safeParse(result.data);
-		if (!parsed.success) return parsed.error.message;
-	};
-	runPipeline = async (name, args, handler) => {
-		const parsedArgs = this.validateToolInput(name, args);
-		if (!parsedArgs.success) {
-			this.callbacks.onLog?.("error", `tool validation error: ${name} error=${parsedArgs.error}`);
-			const err = toolResponseErr(parsedArgs.error);
-			await this.after(name, args, err);
-			return err;
-		}
-		const t0 = Date.now();
-		const result = await handler(parsedArgs.data, this.ctx);
-		this.callbacks.onLog?.("debug", `tool done: ${name} ms=${Date.now() - t0} result=${JSON.stringify(result).slice(0, 200)}`);
-		const outputError = this.validateToolOutput(name, result);
-		if (outputError) this.callbacks.onLog?.("info", `tool output schema drift: ${name} — ${outputError}`);
-		const tool = this.toolsAvailables.get(name);
-		if (!result.isError && tool?.mcpDefinition.outputSchema && result.data !== void 0 && result.data !== null) result.structuredContent = typeof result.data === "object" && !Array.isArray(result.data) ? result.data : { data: result.data };
-		if (result.isError) this.callbacks.onLog?.("error", `tool failed: ${name} error=${firstText(result.content) ?? "unknown"}`);
-		await this.after(name, args, result);
-		return result;
-	};
-	execute = (name, handlerFn) => async (args) => {
-		if (!await this.before(name, args)) return toolResponseErr(`Tool '${name}' execution was blocked`);
-		const handler = handlerFn ?? this.toolsAvailables.get(name)?.handler;
-		if (!handler) {
-			this.callbacks.onLog?.("error", `no handler registered for tool: ${name}`);
-			const err = toolResponseErr(`Tool '${name}' has no handler`);
-			await this.after(name, args, err);
-			return err;
-		}
-		this.callbacks.onLog?.("debug", `tool exec: ${name} args=${JSON.stringify(args).slice(0, 200)}`);
-		return this.runPipeline(name, args, handler);
-	};
-	executePrompt = (_name, handlerFn) => async (args) => {
-		return handlerFn(args, this.ctx);
-	};
-};
-//#endregion
-export { AIEngine as default };

package/dist/modules/ai/toolkit.js

@@ -1,59 +0,0 @@
-import { z } from "zod";
-//#region src/modules/ai/toolkit.ts
-/** Convert a Zod schema to the JSON Schema an AI provider (Anthropic / OpenAI) expects in a tool definition.
-*  Delegates to Zod v4's built-in converter — one implementation, so descriptions, literal discriminators,
-*  enums, nested objects and recursive (z.lazy) shapes all survive and the provider sees the same contract an
-*  MCP client does. `io: 'input'` describes what the agent must SEND; `unrepresentable: 'any'` degrades an
-*  exotic type to an empty schema instead of throwing, so one unusual tool never breaks the whole tool list. */
-var zodToJsonSchema = (schema) => {
-	const json = z.toJSONSchema(schema, {
-		target: "draft-7",
-		io: "input",
-		unrepresentable: "any"
-	});
-	delete json.$schema;
-	return json;
-};
-var firstText = (content) => content.find((block) => block.type === "text")?.text;
-var getAllowedModes = (operationType) => {
-	return operationType === "write" ? ["build"] : ["plan", "build"];
-};
-var toolResponseOk = (data, agentMessage) => {
-	return {
-		content: [{
-			type: "text",
-			text: agentMessage ?? JSON.stringify(data ?? null, null, 2)
-		}],
-		data
-	};
-};
-var toolResponseErr = (error) => ({
-	content: [{
-		type: "text",
-		text: error instanceof Error ? error.message : error
-	}],
-	isError: true
-});
-var isCallToolResult = (result) => typeof result === "object" && result !== null && Array.isArray(result.content);
-var toolResponseFromResult = (result) => {
-	const content = [];
-	for (const block of result.content) if (block.type === "text") content.push({
-		type: "text",
-		text: block.text
-	});
-	else if (block.type === "image") content.push({
-		type: "image",
-		data: block.data,
-		mimeType: block.mimeType
-	});
-	return {
-		content,
-		data: result.structuredContent,
-		isError: result.isError ? true : void 0
-	};
-};
-var isToolActive = (tool) => Boolean(tool.handler);
-var resolveToolHandler = (tool) => tool.handler;
-var bindTools = (tools) => tools.filter(isToolActive);
-//#endregion
-export { bindTools, firstText, getAllowedModes, isCallToolResult, isToolActive, resolveToolHandler, toolResponseErr, toolResponseFromResult, toolResponseOk, zodToJsonSchema };

package/dist/modules/mcp/apps/example/view/index.tsx

@@ -1,70 +0,0 @@
-/* eslint-disable react-refresh/only-export-components -- one bundled entry: components cannot move out. */
-import { useApp, useHostStyles } from '@modelcontextprotocol/ext-apps/react';
-import { useState } from 'react';
-import { createRoot } from 'react-dom/client';
-
-import type { McpUiHostContext } from '@modelcontextprotocol/ext-apps';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-
-/** The smallest MCP App view there is — copy this folder to start a new one. It shows the whole contract:
- *  connect, receive the tool call and its result, call a tool back, and inherit the host's look. Everything it
- *  imports is bundled into the page, so a view that stays this small stays a few KB. */
-
-// Host CSS variables: the chat's own palette and fonts, applied by useHostStyles below.
-const panel = {
-  padding: 16,
-  font: 'var(--font-sans, system-ui, sans-serif)',
-  color: 'var(--color-text-primary, #0f172a)',
-  background: 'var(--color-background-secondary, #f8fafc)',
-  borderRadius: 'var(--border-radius-md, 8px)'
-} as const;
-
-const textOf = (result: CallToolResult): string => result.content.find(entry => entry.type === 'text')?.text ?? '';
-
-const ExampleApp = () => {
-  const [result, setResult] = useState<CallToolResult | null>(null);
-  const [context, setContext] = useState<McpUiHostContext | undefined>(undefined);
-
-  // useApp creates the App, runs onAppCreated so every handler is in place BEFORE the handshake, and connects.
-  const { app, error } = useApp({
-    appInfo: { name: 'Plitzi Example', version: '1.0.0' },
-    capabilities: {},
-    onAppCreated: instance => {
-      // The result of the tool that opened this view. `ontoolinput` gives its arguments instead.
-      instance.ontoolresult = setResult;
-      instance.onhostcontextchanged = params => setContext(previous => ({ ...previous, ...params }));
-      instance.onteardown = () => ({});
-    }
-  });
-
-  useHostStyles(app, context);
-
-  if (error) {
-    return <div style={panel}>Could not connect to the host: {error.message}</div>;
-  }
-
-  if (!app) {
-    return null;
-  }
-
-  const insets = context?.safeAreaInsets;
-  const message = result ? textOf(result) : 'Waiting for the tool result…';
-
-  return (
-    <div style={{ ...panel, margin: `${insets?.top ?? 0}px ${insets?.right ?? 0}px` }}>
-      <p>{message}</p>
-      {/* An app can call the server's tools on its own — each call is a round-trip, so plan for latency. */}
-      <button
-        type="button"
-        onClick={() => void app.callServerTool({ name: 'plitzi_search', arguments: {} }).then(setResult)}
-      >
-        Call plitzi_search
-      </button>
-    </div>
-  );
-};
-
-const root = document.getElementById('app');
-if (root) {
-  createRoot(root).render(<ExampleApp />);
-}

package/dist/modules/mcp/apps/index.js

@@ -1,16 +0,0 @@
-import { registerApp } from "./shared/registerApp.js";
-import { iconFontCss } from "./render/styles.js";
-import { RENDER_APP_URI, renderApp } from "./render/index.js";
-//#region src/modules/mcp/apps/index.ts
-/** What a view gets when the deployment says nothing: streaming on, because a host that streams no arguments
-*  paints exactly what it painted before. */
-var DEFAULT_VIEW_SETTINGS = { streaming: true };
-/** Every MCP App this server serves. A new one is a folder beside `render/` (its definition + its view) and one
-*  line here — the tool that opens it points at its `uri` through `ui: { resourceUri }`. Start from `example/`,
-*  which is that same shape stripped to the minimum. */
-var apps = [renderApp];
-var registerApps = (server, settings = DEFAULT_VIEW_SETTINGS) => {
-	for (const app of apps) registerApp(server, app, settings);
-};
-//#endregion
-export { DEFAULT_VIEW_SETTINGS, RENDER_APP_URI, apps, iconFontCss, registerApps };

package/dist/modules/mcp/apps/render/index.js

@@ -1,17 +0,0 @@
-import { VIEW_DIR } from "../shared/assets.js";
-import { iconFontCss, widgetCss } from "./styles.js";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/modules/mcp/apps/render/index.ts
-var RENDER_APP_URI = "ui://plitzi/render.html";
-var HERE = path.dirname(fileURLToPath(import.meta.url));
-var renderApp = {
-	uri: RENDER_APP_URI,
-	name: "plitzi-render-app",
-	title: "Plitzi widget",
-	description: "Interactive view that renders a plitzi_render widget with the Plitzi SDK.",
-	entry: path.join(HERE, VIEW_DIR, "index.tsx"),
-	styles: () => [widgetCss()]
-};
-//#endregion
-export { RENDER_APP_URI, iconFontCss, renderApp };

package/dist/modules/mcp/apps/render/styles.js

@@ -1,54 +0,0 @@
-import { require } from "../shared/resolve.js";
-import path from "node:path";
-import { readFileSync } from "node:fs";
-//#region src/modules/mcp/apps/render/styles.ts
-/** The SDK stylesheet, split in two.
-*
-*  Everything the page shell inlines is paid for by EVERY widget: the host loads the ui:// page into a fresh
-*  sandboxed iframe and parses it whole before anything paints, which is the "Rendering…" the user waits through.
-*  Three of those @font-face blocks are Font Awesome shipped as base64 woff2 — ~330 KB, close to a fifth of the
-*  page — and only a widget that authored a `fontAwesome` element has any use for them.
-*
-*  So the shell takes the base, and the fonts travel in the tool result of the renders that actually draw an icon
-*  (see tools/render.ts). A widget without icons never downloads a glyph; one with icons looks exactly the same as
-*  before. */
-/** Where the closing brace of the block opened at `open` is, so a nested one cannot end it early. Returns the
-*  string's length when the CSS is truncated mid-block, which drops that tail rather than mixing it into the base. */
-var blockEnd = (css, open) => {
-	let depth = 0;
-	for (let at = open; at < css.length; at++) if (css[at] === "{") depth++;
-	else if (css[at] === "}") {
-		depth--;
-		if (depth === 0) return at + 1;
-	}
-	return css.length;
-};
-/** Lifts every @font-face block out of a stylesheet. Brace counting rather than a CSS parser: a @font-face body is
-*  plain declarations, and base64 payloads and url() values carry no braces of their own. */
-var splitFontFaces = (css) => {
-	const base = [];
-	const fonts = [];
-	let cursor = 0;
-	for (let at = css.indexOf("@font-face", cursor); at !== -1; at = css.indexOf("@font-face", cursor)) {
-		const open = css.indexOf("{", at);
-		if (open === -1) break;
-		const end = blockEnd(css, open);
-		base.push(css.slice(cursor, at));
-		fonts.push(css.slice(at, end));
-		cursor = end;
-	}
-	base.push(css.slice(cursor));
-	return {
-		base: base.join(""),
-		fonts: fonts.join("")
-	};
-};
-var stylesheet = () => readFileSync(path.join(path.dirname(require.resolve("@plitzi/plitzi-sdk")), "plitzi-sdk.css"), "utf-8");
-var split;
-var sdkStyles = () => split ??= splitFontFaces(stylesheet());
-/** What the page shell inlines: the SDK stylesheet without the icon fonts. */
-var widgetCss = () => sdkStyles().base;
-/** The icon fonts, for the renders that draw one. */
-var iconFontCss = () => sdkStyles().fonts;
-//#endregion
-export { iconFontCss, splitFontFaces, widgetCss };

package/dist/modules/mcp/apps/render/view/heldBatch.ts

@@ -1,107 +0,0 @@
-/** Where the batch a widget was built from survives between calls — on the HOST, so the server can keep nothing.
- *
- *  It cannot live in the view's memory: the Apps spec binds a view to ONE tool call (`ui/notifications/tool-input`
- *  is sent "at most once", and the host renders a fresh iframe when a UI tool is called), so the patch call the
- *  model makes arrives in a brand-new instance whose memory is empty. localStorage keyed by an id the server hands
- *  back is the spec's own state-persistence pattern (`_meta.viewUUID` in the Apps docs); here the key is the
- *  renderId, which the model also carries, so a patch names the widget it means instead of assuming "the last one".
- */
-
-const PREFIX = 'plitzi.render.';
-const MAX_ENTRIES = 5;
-// A renderId only lives in one conversation's context, so a batch outlives its usefulness the moment that
-// conversation is over — and a conversation the user abandoned would otherwise leave its widget in the host's
-// storage for good. Generous enough that no live conversation loses its widget, short enough to be housekeeping.
-const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-
-type Stored = { savedAt: number; operations: unknown[] };
-
-// A sandboxed iframe without allow-same-origin throws on the ACCESS to localStorage, not on the call — so even
-// reading the property has to be guarded. A host that denies storage simply gets no patching.
-const localStore = (): Storage | undefined => {
-  try {
-    return window.localStorage;
-  } catch {
-    return undefined;
-  }
-};
-
-const parse = (raw: string | null): Stored | undefined => {
-  if (raw === null) {
-    return undefined;
-  }
-
-  try {
-    const value = JSON.parse(raw) as Stored;
-
-    return Array.isArray(value.operations) ? value : undefined;
-  } catch {
-    return undefined;
-  }
-};
-
-const ownKeys = (store: Storage): string[] => {
-  const keys: string[] = [];
-  for (let index = 0; index < store.length; index += 1) {
-    const key = store.key(index);
-    if (key !== null && key.startsWith(PREFIX)) {
-      keys.push(key);
-    }
-  }
-
-  return keys;
-};
-
-const dropStale = (store: Storage, keep: string): void => {
-  const others = ownKeys(store)
-    .filter(key => key !== keep)
-    .map(key => ({ key, savedAt: parse(store.getItem(key))?.savedAt ?? 0 }))
-    .sort((a, b) => b.savedAt - a.savedAt);
-  const expired = Date.now() - MAX_AGE_MS;
-
-  for (const [index, entry] of others.entries()) {
-    if (index >= MAX_ENTRIES - 1 || entry.savedAt < expired) {
-      store.removeItem(entry.key);
-    }
-  }
-};
-
-export const readHeldBatch = (renderId: string, store = localStore()): unknown[] | undefined => {
-  if (!store) {
-    return undefined;
-  }
-
-  const stored = parse(store.getItem(`${PREFIX}${renderId}`));
-  if (!stored || stored.savedAt < Date.now() - MAX_AGE_MS) {
-    return undefined;
-  }
-
-  return stored.operations;
-};
-
-export const writeHeldBatch = (renderId: string, operations: unknown[], store = localStore()): void => {
-  if (!store) {
-    return;
-  }
-
-  const key = `${PREFIX}${renderId}`;
-  const payload = JSON.stringify({ savedAt: Date.now(), operations } satisfies Stored);
-
-  try {
-    dropStale(store, key);
-    store.setItem(key, payload);
-  } catch {
-    // Out of quota: the widget just rendered is the only one still worth patching, so the rest go.
-    for (const other of ownKeys(store)) {
-      if (other !== key) {
-        store.removeItem(other);
-      }
-    }
-
-    try {
-      store.setItem(key, payload);
-    } catch {
-      // Storage is full or refused: patching degrades to "re-send the full batch", never to a wrong widget.
-    }
-  }
-};