@design-ai/cli 4.55.0 → 4.57.0

package/cli/lib/lexical.mjs

@@ -0,0 +1,137 @@
+// Shared deterministic lexical (BM25-style) scoring for corpus and learning retrieval.
+// Phase A of docs/AI-LEARNING-PHASE2.md: zero-dependency, no randomness, no time-dependent scoring.
+
+export const BM25_K1 = 1.2;
+export const BM25_B = 0.75;
+
+// Hangul syllable block (U+AC00–U+D7A3). Korean surface forms are written without
+// spaces between stem and particle (버튼을, 접근성이), so a whitespace-delimited token
+// is an atomic surface form. To let a stem query match particle-attached documents
+// (and vice versa), we deterministically expand every Hangul run of length >= 2 into
+// its overlapping character bigrams and emit them ALONGSIDE the original token.
+//   버튼을 -> keep 버튼을, add 버튼, 튼을
+//   접근성 -> keep 접근성, add 접근, 근성
+//   버튼   -> the 2-char run's only bigram is itself; kept via dedupe
+// Latin/number tokens and mixed tokens' non-Hangul parts are unchanged. The rule is
+// pure and deterministic (no locale, no time, no randomness); order is normalized by
+// the dedupe+sort in lexicalQueryTokens and by termFrequencies for stats.
+const HANGUL_RUN = /[가-힣]{2,}/gu;
+
+function hangulBigrams(token) {
+  const bigrams = [];
+  for (const run of token.match(HANGUL_RUN) || []) {
+    for (let i = 0; i + 2 <= run.length; i += 1) {
+      bigrams.push(run.slice(i, i + 2));
+    }
+  }
+  return bigrams;
+}
+
+// Same base token model as learn-select.mjs: Unicode letters/numbers, lowercased,
+// length >= 2. Hangul tokens additionally emit character bigrams (see HANGUL_RUN).
+export function lexicalTokens(text) {
+  const base = (String(text || "")
+    .toLowerCase()
+    .match(/[\p{L}\p{N}]+/gu) || [])
+    .filter((token) => token.length >= 2);
+
+  const expanded = [];
+  for (const token of base) {
+    expanded.push(token);
+    for (const bigram of hangulBigrams(token)) {
+      // A 2-char Hangul run's only bigram is the token itself; do not re-emit it,
+      // which would double-count its term frequency and distort BM25.
+      if (bigram !== token) expanded.push(bigram);
+    }
+  }
+  return expanded;
+}
+
+export function lexicalQueryTokens(query) {
+  return Array.from(new Set(lexicalTokens(query))).sort();
+}
+
+function termFrequencies(tokens) {
+  const terms = {};
+  for (const token of tokens) {
+    terms[token] = (terms[token] || 0) + 1;
+  }
+  const sorted = {};
+  for (const term of Object.keys(terms).sort()) {
+    sorted[term] = terms[term];
+  }
+  return sorted;
+}
+
+// documents: [{ id, text }] -> deterministic index stats with sorted ids and term keys.
+export function buildLexicalStats(documents) {
+  const indexed = [...documents]
+    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    .map((doc) => {
+      const tokens = lexicalTokens(doc.text);
+      return { id: doc.id, length: tokens.length, terms: termFrequencies(tokens) };
+    });
+
+  const docFrequency = {};
+  for (const doc of indexed) {
+    for (const term of Object.keys(doc.terms)) {
+      docFrequency[term] = (docFrequency[term] || 0) + 1;
+    }
+  }
+  const sortedDocFrequency = {};
+  for (const term of Object.keys(docFrequency).sort()) {
+    sortedDocFrequency[term] = docFrequency[term];
+  }
+
+  const totalLength = indexed.reduce((sum, doc) => sum + doc.length, 0);
+  return {
+    documentCount: indexed.length,
+    termCount: Object.keys(sortedDocFrequency).length,
+    avgDocLength: indexed.length > 0 ? totalLength / indexed.length : 0,
+    docFrequency: sortedDocFrequency,
+    documents: indexed,
+  };
+}
+
+function inverseDocumentFrequency(documentCount, docFrequency) {
+  return Math.log(1 + (documentCount - docFrequency + 0.5) / (docFrequency + 0.5));
+}
+
+export function bm25Score(queryTokens, doc, stats) {
+  if (stats.documentCount === 0 || doc.length === 0) return { score: 0, matchedTokens: [] };
+
+  let score = 0;
+  const matchedTokens = [];
+  for (const token of queryTokens) {
+    const tf = doc.terms[token] || 0;
+    if (tf === 0) continue;
+    const df = stats.docFrequency[token] || 0;
+    const idf = inverseDocumentFrequency(stats.documentCount, df);
+    const lengthNorm = 1 - BM25_B + BM25_B * (doc.length / (stats.avgDocLength || 1));
+    score += idf * ((tf * (BM25_K1 + 1)) / (tf + BM25_K1 * lengthNorm));
+    matchedTokens.push(token);
+  }
+  return { score, matchedTokens };
+}
+
+// Fully ordered ranking: score desc, then id asc. Zero-score documents are excluded.
+export function rankLexical(query, stats, { limit = 20 } = {}) {
+  const queryTokens = lexicalQueryTokens(query);
+  if (queryTokens.length === 0) return [];
+
+  const ranked = [];
+  for (const doc of stats.documents) {
+    const { score, matchedTokens } = bm25Score(queryTokens, doc, stats);
+    if (score > 0) {
+      ranked.push({ id: doc.id, score, matchedTokens });
+    }
+  }
+  ranked.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+  return ranked.slice(0, limit).map((hit) => ({
+    ...hit,
+    score: Number(hit.score.toFixed(6)),
+  }));
+}

package/cli/lib/local-config.mjs

@@ -0,0 +1,110 @@
+// Local, user-authored configuration for optional Phase B features
+// (docs/AI-LEARNING-PHASE2.md, "Phase A implementation review", decision 5 / FU-4).
+//
+// design-ai never writes this file. It is durable, per-machine, user-authored
+// configuration — the CLI only reads it. Presence of a configured provider is
+// NOT enough to enable embeddings: every consumer still requires the explicit
+// per-invocation --embeddings flag (config supplies the provider, the flag arms it).
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+export function defaultConfigFile() {
+  return process.env.DESIGN_AI_CONFIG_FILE || path.join(homedir(), ".design-ai", "config.json");
+}
+
+const TOP_LEVEL_KEYS = new Set(["version", "embeddings"]);
+const EMBEDDINGS_KEYS = new Set(["provider", "modelLabel"]);
+const PROVIDER_KEYS = new Set(["command", "args"]);
+
+function fail(message) {
+  return { present: true, config: null, error: message };
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function validateProvider(provider) {
+  if (!isPlainObject(provider)) return "embeddings.provider must be an object";
+
+  const unknown = Object.keys(provider).filter((key) => !PROVIDER_KEYS.has(key));
+  if (unknown.length > 0) return `embeddings.provider has unknown key(s): ${unknown.join(", ")}`;
+
+  if (typeof provider.command !== "string" || provider.command.trim() === "") {
+    return "embeddings.provider.command is required and must be a non-empty string";
+  }
+
+  if (provider.args !== undefined) {
+    if (!Array.isArray(provider.args) || !provider.args.every((arg) => typeof arg === "string")) {
+      return "embeddings.provider.args must be an array of strings";
+    }
+  }
+
+  return "";
+}
+
+function validateEmbeddings(embeddings) {
+  if (!isPlainObject(embeddings)) return "embeddings must be an object";
+
+  const unknown = Object.keys(embeddings).filter((key) => !EMBEDDINGS_KEYS.has(key));
+  if (unknown.length > 0) return `embeddings has unknown key(s): ${unknown.join(", ")}`;
+
+  if (embeddings.provider === undefined) return "embeddings.provider is required";
+  const providerError = validateProvider(embeddings.provider);
+  if (providerError) return providerError;
+
+  if (embeddings.modelLabel !== undefined && typeof embeddings.modelLabel !== "string") {
+    return "embeddings.modelLabel must be a string";
+  }
+
+  return "";
+}
+
+function validateConfig(config) {
+  if (!isPlainObject(config)) return "config must be a JSON object";
+
+  const unknown = Object.keys(config).filter((key) => !TOP_LEVEL_KEYS.has(key));
+  if (unknown.length > 0) return `config has unknown top-level key(s): ${unknown.join(", ")}`;
+
+  if (config.version !== 1) return "config.version must be 1";
+
+  if (config.embeddings !== undefined) {
+    const embeddingsError = validateEmbeddings(config.embeddings);
+    if (embeddingsError) return embeddingsError;
+  }
+
+  return "";
+}
+
+// Never writes; design-ai only reads this user-authored file.
+export function loadLocalConfig(filePath = defaultConfigFile()) {
+  if (!existsSync(filePath)) return { present: false, config: null, error: "" };
+
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf8");
+  } catch (error) {
+    return fail(`unreadable config file: ${error.message}`);
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return fail(`config file is not valid JSON: ${error.message}`);
+  }
+
+  const error = validateConfig(parsed);
+  if (error) return fail(error);
+
+  return { present: true, config: parsed, error: "" };
+}
+
+// Convenience accessor: the configured embedding provider, or null when absent
+// or the config is malformed/missing. Callers still must gate on --embeddings.
+export function configuredEmbeddingProvider(filePath = defaultConfigFile()) {
+  const { config } = loadLocalConfig(filePath);
+  return config?.embeddings?.provider || null;
+}

package/cli/lib/mcp-server.mjs

@@ -10,6 +10,14 @@ import { DESIGN_AI_HOME, PACKAGE_ROOT } from "./paths.mjs";
 const PROTOCOL_VERSION = "2025-11-25";
 const MAX_TOOL_OUTPUT_BYTES = 220_000;
 const DESIGN_AI_BIN = path.join(PACKAGE_ROOT, "cli", "bin", "design-ai.mjs");
+const MCP_RESPONSE_METHODS = new Set([
+  "initialize",
+  "ping",
+  "tools/list",
+  "tools/call",
+  "resources/list",
+  "prompts/list",
+]);
 
 function optionalString(description = "") {
   return { type: "string", description };
@@ -42,7 +50,7 @@ export const MCP_TOOLS = [
   {
     name: "design_ai_prompt",
     title: "Generate an agent prompt",
-    description: "Generate a ready-to-use design-ai agent prompt from a brief. Read-only unless withLearning is true, which records local usage metadata.",
+    description: "Generate a ready-to-use design-ai agent prompt from a brief. Read-only unless withLearning is true, which records local usage metadata. Supports opt-in recall augmentation via withRecall, which enriches the output with brief-relevant shipped corpus knowledge.",
     inputSchema: {
       type: "object",
       properties: {
@@ -51,6 +59,8 @@ export const MCP_TOOLS = [
         withLearning: optionalBoolean("Include local learning preferences and record local usage metadata."),
         learningCategory: optionalString("Optional learning category when withLearning is true."),
         learningLimit: optionalInteger({ description: "Maximum learning entries, 1-100.", minimum: 1, maximum: 100 }),
+        withRecall: optionalBoolean("Opt-in recall augmentation: enriches the output with brief-relevant shipped corpus knowledge ranked by the deterministic lexical scorer. Requires no index and makes no network call."),
+        recallLimit: optionalInteger({ description: "Maximum recall passages, 1-20.", minimum: 1, maximum: 20 }),
         json: optionalBoolean("Return machine-readable prompt plan JSON instead of Markdown."),
       },
       required: ["brief"],
@@ -60,7 +70,7 @@ export const MCP_TOOLS = [
   {
     name: "design_ai_pack",
     title: "Generate prompt plus bounded context",
-    description: "Generate a prompt pack with relevant design-ai context files. Read-only unless withLearning is true, which records local usage metadata.",
+    description: "Generate a prompt pack with relevant design-ai context files. Read-only unless withLearning is true, which records local usage metadata. Supports opt-in recall augmentation via withRecall, which enriches the output with brief-relevant shipped corpus knowledge.",
     inputSchema: {
       type: "object",
       properties: {
@@ -70,6 +80,8 @@ export const MCP_TOOLS = [
         withLearning: optionalBoolean("Include local learning preferences and record local usage metadata."),
         learningCategory: optionalString("Optional learning category when withLearning is true."),
         learningLimit: optionalInteger({ description: "Maximum learning entries, 1-100.", minimum: 1, maximum: 100 }),
+        withRecall: optionalBoolean("Opt-in recall augmentation: enriches the output with brief-relevant shipped corpus knowledge ranked by the deterministic lexical scorer. Requires no index and makes no network call."),
+        recallLimit: optionalInteger({ description: "Maximum recall passages, 1-20.", minimum: 1, maximum: 20 }),
         json: optionalBoolean("Return machine-readable pack JSON instead of Markdown."),
       },
       required: ["brief"],
@@ -79,13 +91,14 @@ export const MCP_TOOLS = [
   {
     name: "design_ai_search",
     title: "Search design-ai corpus",
-    description: "Search knowledge, examples, skills, docs, agents, or commands. Read-only.",
+    description: "Search knowledge, examples, skills, docs, agents, or commands. Read-only. Supports an opt-in ranked mode for deterministic BM25-style results.",
     inputSchema: {
       type: "object",
       properties: {
         query: { type: "string", minLength: 2, description: "Search query." },
         dir: optionalString("Optional corpus directory: knowledge, examples, skills, docs, agents, commands."),
         limit: optionalInteger({ description: "Maximum hits, 1-500.", minimum: 1, maximum: 500 }),
+        ranked: optionalBoolean("Opt-in deterministic BM25-style ranked results. Requires no index and never builds one; falls back to a live corpus scan when no index is present."),
       },
       required: ["query"],
       additionalProperties: false,
@@ -196,6 +209,51 @@ function assertString(value, name) {
   return value;
 }
 
+function assertMcpInputValue(name, value, schema) {
+  if (schema.type === "string") {
+    if (typeof value !== "string") throw new Error(`${name} must be a string`);
+    if (schema.minLength && value.trim() === "") {
+      throw new Error(`${name} must be a non-empty string`);
+    }
+    if (schema.minLength && value.length < schema.minLength) {
+      throw new Error(`${name} must be at least ${schema.minLength} characters`);
+    }
+    return;
+  }
+
+  if (schema.type === "boolean") {
+    if (typeof value !== "boolean") throw new Error(`${name} must be a boolean`);
+    return;
+  }
+
+  if (schema.type === "integer") {
+    if (!Number.isInteger(value)) throw new Error(`${name} must be an integer`);
+    if (schema.minimum !== undefined && value < schema.minimum) {
+      throw new Error(`${name} must be at least ${schema.minimum}`);
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+      throw new Error(`${name} must be at most ${schema.maximum}`);
+    }
+  }
+}
+
+function assertMcpToolInput(tool, input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(`${tool.name} arguments must be an object`);
+  }
+
+  const properties = tool.inputSchema.properties || {};
+  for (const name of tool.inputSchema.required || []) {
+    if (!Object.hasOwn(input, name)) throw new Error(`${tool.name}.${name} is required`);
+  }
+
+  for (const [name, value] of Object.entries(input)) {
+    const schema = properties[name];
+    if (!schema) throw new Error(`Unknown argument for ${tool.name}: ${name}`);
+    assertMcpInputValue(`${tool.name}.${name}`, value, schema);
+  }
+}
+
 function maybePush(args, flag, value) {
   if (value !== undefined && value !== null && value !== "") args.push(flag, String(value));
 }
@@ -228,6 +286,8 @@ export function buildCliInvocation(toolName, input = {}) {
     maybeBool(args, "--with-learning", input.withLearning);
     maybePush(args, "--learning-category", input.learningCategory);
     maybePush(args, "--learning-limit", input.learningLimit);
+    maybeBool(args, "--with-recall", input.withRecall);
+    maybePush(args, "--recall-limit", input.recallLimit);
     maybeBool(args, "--json", input.json);
     return { args, stdin };
   }
@@ -239,6 +299,8 @@ export function buildCliInvocation(toolName, input = {}) {
     maybeBool(args, "--with-learning", input.withLearning);
     maybePush(args, "--learning-category", input.learningCategory);
     maybePush(args, "--learning-limit", input.learningLimit);
+    maybeBool(args, "--with-recall", input.withRecall);
+    maybePush(args, "--recall-limit", input.recallLimit);
     maybeBool(args, "--json", input.json);
     return { args, stdin };
   }
@@ -247,6 +309,7 @@ export function buildCliInvocation(toolName, input = {}) {
     args.push("search", assertString(input.query, "query"), "--json");
     maybePush(args, "--dir", input.dir);
     maybePush(args, "--limit", input.limit);
+    maybeBool(args, "--ranked", input.ranked);
     return { args, stdin };
   }
 
@@ -328,6 +391,9 @@ export function runDesignAiCli(args, { stdin = "" } = {}) {
 }
 
 export async function callMcpTool(name, input = {}, runCli = runDesignAiCli) {
+  const tool = MCP_TOOLS.find((item) => item.name === name);
+  if (tool) assertMcpToolInput(tool, input || {});
+
   const invocation = buildCliInvocation(name, input || {});
   const result = await runCli(invocation.args, { stdin: invocation.stdin });
   const text = [
@@ -349,14 +415,131 @@ function errorResponse(id, code, message) {
   return { jsonrpc: "2.0", id: id ?? null, error: { code, message } };
 }
 
+function chooseProtocolVersion(requestedVersion) {
+  return requestedVersion === PROTOCOL_VERSION ? requestedVersion : PROTOCOL_VERSION;
+}
+
+function isObjectRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function validateMcpRequestEnvelope(message) {
+  if (!isObjectRecord(message)) {
+    return "Invalid MCP request: request must be an object";
+  }
+  if (message.jsonrpc !== "2.0") {
+    return 'Invalid MCP request: jsonrpc must be "2.0"';
+  }
+  if (hasRequestId(message) && !isValidMcpRequestId(message.id)) {
+    return "Invalid MCP request: id must be a string, number, or null";
+  }
+  return "";
+}
+
+function validateMcpRequestMethod(message) {
+  if (!Object.hasOwn(message, "method")) {
+    return "Invalid MCP request: missing method";
+  }
+  if (typeof message.method !== "string" || message.method.trim() === "") {
+    return "Invalid MCP request: method must be a non-empty string";
+  }
+  return "";
+}
+
+function isMcpNotificationMethod(method) {
+  return typeof method === "string" && method.startsWith("notifications/");
+}
+
+function validateMcpNotificationRequest(message) {
+  if (isMcpNotificationMethod(message.method) && hasRequestId(message)) {
+    return `Invalid MCP request: ${message.method} must not include id`;
+  }
+  return "";
+}
+
+function validateMcpRequestIdRequirement(message) {
+  if (MCP_RESPONSE_METHODS.has(message.method) && !hasRequestId(message)) {
+    return `Invalid MCP request: ${message.method} must include id`;
+  }
+  return "";
+}
+
+function validateOptionalObjectParams(method, params) {
+  if (params === undefined || isObjectRecord(params)) return "";
+  return `${method} params must be an object when provided`;
+}
+
+function validateToolCallParams(params) {
+  if (!isObjectRecord(params)) {
+    return "tools/call params must be an object";
+  }
+  if (typeof params.name !== "string" || params.name.trim() === "") {
+    return "tools/call params.name must be a non-empty string";
+  }
+  if (Object.hasOwn(params, "arguments") && params.arguments !== undefined && !isObjectRecord(params.arguments)) {
+    return "tools/call params.arguments must be an object when provided";
+  }
+  return "";
+}
+
+function validateInitializeParams(params) {
+  if (!isObjectRecord(params)) {
+    return "initialize params must be an object";
+  }
+  if (Object.hasOwn(params, "protocolVersion") && typeof params.protocolVersion !== "string") {
+    return "initialize params.protocolVersion must be a string";
+  }
+  if (typeof params.protocolVersion === "string" && params.protocolVersion.trim() === "") {
+    return "initialize params.protocolVersion must be a non-empty string";
+  }
+  return "";
+}
+
+function hasRequestId(message) {
+  return isObjectRecord(message) && Object.hasOwn(message, "id");
+}
+
+function isValidMcpRequestId(id) {
+  return id === null || typeof id === "string" || (typeof id === "number" && Number.isFinite(id));
+}
+
+function responseIdForMessage(message) {
+  if (!hasRequestId(message)) return undefined;
+  return isValidMcpRequestId(message.id) ? message.id : undefined;
+}
+
+function isInvalidRequestResponse(response) {
+  return response?.error?.code === -32600;
+}
+
+function shouldWriteMcpResponse(message, response) {
+  if (!response) return false;
+  return hasRequestId(message) || isInvalidRequestResponse(response);
+}
+
 export async function handleMcpRequest(message, { runCli = runDesignAiCli } = {}) {
-  const { id, method, params = {} } = message || {};
+  const id = responseIdForMessage(message);
+  const envelopeError = validateMcpRequestEnvelope(message);
+  if (envelopeError) return errorResponse(id, -32600, envelopeError);
+
+  const methodError = validateMcpRequestMethod(message);
+  if (methodError) return errorResponse(id, -32600, methodError);
+
+  const notificationError = validateMcpNotificationRequest(message);
+  if (notificationError) return errorResponse(id, -32600, notificationError);
+
+  const requestIdError = validateMcpRequestIdRequirement(message);
+  if (requestIdError) return errorResponse(id, -32600, requestIdError);
 
-  if (!method) return errorResponse(id, -32600, "Invalid MCP request: missing method");
+  const { method, params } = message;
 
   if (method === "initialize") {
+    const initializeParams = params === undefined ? {} : params;
+    const paramsError = validateInitializeParams(initializeParams);
+    if (paramsError) return errorResponse(id, -32602, paramsError);
+
     return successResponse(id, {
-      protocolVersion: params.protocolVersion || PROTOCOL_VERSION,
+      protocolVersion: chooseProtocolVersion(initializeParams.protocolVersion),
       capabilities: {
         tools: { listChanged: false },
       },
@@ -368,19 +551,36 @@ export async function handleMcpRequest(message, { runCli = runDesignAiCli } = {}
     });
   }
 
-  if (method === "notifications/initialized") return null;
-  if (method === "ping") return successResponse(id, {});
+  if (isMcpNotificationMethod(method)) return null;
+  if (method === "ping") {
+    const paramsError = validateOptionalObjectParams(method, params);
+    if (paramsError) return errorResponse(id, -32602, paramsError);
+    return successResponse(id, {});
+  }
 
   if (method === "tools/list") {
+    const paramsError = validateOptionalObjectParams(method, params);
+    if (paramsError) return errorResponse(id, -32602, paramsError);
     return successResponse(id, { tools: MCP_TOOLS });
   }
 
   if (method === "tools/call") {
+    const paramsError = validateToolCallParams(params);
+    if (paramsError) return errorResponse(id, -32602, paramsError);
+
     const name = params.name;
     const tool = MCP_TOOLS.find((item) => item.name === name);
     if (!tool) return errorResponse(id, -32602, `Unknown tool: ${name}`);
+
+    const toolArguments = params.arguments === undefined ? {} : params.arguments;
     try {
-      const result = await callMcpTool(name, params.arguments || {}, runCli);
+      assertMcpToolInput(tool, toolArguments);
+    } catch (validationError) {
+      return errorResponse(id, -32602, validationError.message || String(validationError));
+    }
+
+    try {
+      const result = await callMcpTool(name, toolArguments, runCli);
       return successResponse(id, result);
     } catch (error) {
       return successResponse(id, {
@@ -390,8 +590,16 @@ export async function handleMcpRequest(message, { runCli = runDesignAiCli } = {}
     }
   }
 
-  if (method === "resources/list") return successResponse(id, { resources: [] });
-  if (method === "prompts/list") return successResponse(id, { prompts: [] });
+  if (method === "resources/list") {
+    const paramsError = validateOptionalObjectParams(method, params);
+    if (paramsError) return errorResponse(id, -32602, paramsError);
+    return successResponse(id, { resources: [] });
+  }
+  if (method === "prompts/list") {
+    const paramsError = validateOptionalObjectParams(method, params);
+    if (paramsError) return errorResponse(id, -32602, paramsError);
+    return successResponse(id, { prompts: [] });
+  }
 
   return errorResponse(id, -32601, `Method not found: ${method}`);
 }
@@ -411,11 +619,11 @@ export function startMcpStdioServer({ input = process.stdin, output = process.st
 
     try {
       const response = await handleMcpRequest(message);
-      if (response && message.id !== undefined) {
+      if (shouldWriteMcpResponse(message, response)) {
         output.write(`${JSON.stringify(response)}\n`);
       }
     } catch (requestError) {
-      const id = message && message.id !== undefined ? message.id : null;
+      const id = responseIdForMessage(message) ?? null;
       output.write(`${JSON.stringify(errorResponse(id, -32603, requestError.message || String(requestError)))}\n`);
     }
   });