product-spec-mcp 0.3.26 → 0.3.28

package/dist/index.cjs

@@ -29682,7 +29682,7 @@ function registerProductSpecAssist(server) {
 function createServer() {
   const server = new McpServer({
     name: "product-spec-mcp",
-    version: "0.3.26"
+    version: "0.3.28"
   });
   registerSpecInterrogate(server);
   registerSpecCompile(server);

package/docs/online-pm-gate.md

@@ -41,11 +41,35 @@ wrangler kv namespace create PROMPT_CACHE
 wrangler d1 create product-spec-prompt-samples
 wrangler d1 execute product-spec-prompt-samples --file schema.sql
 wrangler secret put GATE_TOKEN
-wrangler secret put DEEPSEEK_API_KEY
+wrangler secret put MIMO_API_KEY
 wrangler secret put RATE_LIMIT_SALT
 wrangler deploy
 ```
 
+Default LLM provider:
+
+```toml
+[vars]
+LLM_PROVIDER = "mimo"
+LLM_BASE_URL = "https://token-plan-cn.xiaomimimo.com/v1"
+LLM_MODEL = "mimo-v2.5"
+```
+
+To switch later to DeepSeek, change the Worker vars to:
+
+```toml
+[vars]
+LLM_PROVIDER = "deepseek"
+LLM_BASE_URL = "https://api.deepseek.com"
+LLM_MODEL = "deepseek-chat"
+```
+
+Then set:
+
+```bash
+wrangler secret put DEEPSEEK_API_KEY
+```
+
 Runtime behavior:
 
 - Prompt cache key: `cache:{model}:{promptHash}:pm-gate-v1`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "product-spec-mcp",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "description": "MCP Server for product specification - requirement interrogation, architecture decision, UI translation, debug guidance, and acceptance generation",
   "type": "commonjs",
   "main": "dist/index.cjs",

package/workers/pm-intent-gate.mjs

@@ -1,5 +1,9 @@
 const GATE_SCHEMA_VERSION = "pm-gate-v1";
-const DEFAULT_MODEL = "deepseek-chat";
+const DEFAULT_PROVIDER = "mimo";
+const DEFAULT_MIMO_BASE_URL = "https://token-plan-cn.xiaomimimo.com/v1";
+const DEFAULT_MIMO_MODEL = "mimo-v2.5";
+const DEFAULT_DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+const DEFAULT_DEEPSEEK_MODEL = "deepseek-chat";
 const DAILY_LIMIT = 3;
 
 export default {
@@ -25,8 +29,8 @@ export default {
     const telemetryMode = normalizeTelemetry(request.headers.get("x-product-spec-telemetry") || "off");
     const message = String(body.message || "").slice(0, 500);
     const messageHash = body.messageHash || await sha256(normalizeText(message));
-    const model = env.DEEPSEEK_MODEL || DEFAULT_MODEL;
-    const cacheKey = `cache:${model}:${messageHash}:${GATE_SCHEMA_VERSION}`;
+    const llm = resolveLlmConfig(env);
+    const cacheKey = `cache:${llm.provider}:${llm.model}:${messageHash}:${GATE_SCHEMA_VERSION}`;
     const cached = await env.PROMPT_CACHE?.get(cacheKey, "json");
     const ipKey = await rateLimitKey(request, env);
     const resetAt = nextShanghaiMidnightIso();
@@ -41,8 +45,8 @@ export default {
         decision: cached.decision,
         llmGate: {
           used: false,
-          provider: "deepseek",
-          model,
+          provider: llm.provider,
+          model: llm.model,
           promptTokensApprox: cached.promptTokensApprox || 0,
           completionTokensApprox: cached.completionTokensApprox || 0,
           cacheHit: true,
@@ -66,7 +70,7 @@ export default {
       });
       return json({
         decision: fallbackDecision(body.ruleDecision),
-        llmGate: { used: false, provider: "deepseek", model, cacheHit: false },
+        llmGate: { used: false, provider: llm.provider, model: llm.model, cacheHit: false },
         rateLimit: { limit: DAILY_LIMIT, remaining: 0, resetAt },
         privacy: privacyResult(telemetryMode),
       }, 429);
@@ -79,7 +83,7 @@ export default {
     let completionTokensApprox = 0;
     let fallbackReason = "";
     try {
-      const llmText = await callDeepSeek(env, model, prompt);
+      const llmText = await callOpenAiCompatible(llm, prompt);
       completionTokensApprox = approxTokens(llmText);
       llmDecision = sanitizeDecision(extractJson(llmText));
       if (!llmDecision) fallbackReason = "invalid_llm_schema";
@@ -109,8 +113,8 @@ export default {
       decision: finalDecision,
       llmGate: {
         used: Boolean(llmDecision),
-        provider: "deepseek",
-        model,
+        provider: llm.provider,
+        model: llm.model,
         promptTokensApprox,
         completionTokensApprox,
         cacheHit: false,
@@ -133,7 +137,21 @@ function isAuthorized(request, env) {
 
 function buildGatePrompt(message, rule, choices) {
   return JSON.stringify({
-    task: "Choose the best PM gate only. Return strict JSON, no markdown.",
+    task: "Choose the best PM gate only. Return strict JSON only.",
+    example: {
+      bestGate: "data_visualization_site",
+      usageScope: "self",
+      maintenanceMode: "agent_assisted",
+      accessTopology: "single_device",
+      confidence: "medium",
+      strongSignals: ["xlsx"],
+      weakSignals: ["website"],
+      coreObjects: ["xlsx file"],
+      states: [],
+      actions: ["parse xlsx", "render chart"],
+      mustNotUse: ["admin_backend_by_default"],
+      boundaryQuestionIds: ["data_update_mode"],
+    },
     output: {
       bestGate: "one needType enum",
       usageScope: "one usageScope enum",
@@ -159,46 +177,136 @@ function buildGatePrompt(message, rule, choices) {
   });
 }
 
-async function callDeepSeek(env, model, prompt) {
-  if (!env.DEEPSEEK_API_KEY) throw new Error("missing_deepseek_api_key");
-  const response = await fetch("https://api.deepseek.com/chat/completions", {
+function resolveLlmConfig(env) {
+  const provider = String(env.LLM_PROVIDER || DEFAULT_PROVIDER).toLowerCase();
+  if (provider === "deepseek") {
+    return {
+      provider,
+      baseUrl: env.LLM_BASE_URL || env.DEEPSEEK_BASE_URL || DEFAULT_DEEPSEEK_BASE_URL,
+      model: env.LLM_MODEL || env.DEEPSEEK_MODEL || DEFAULT_DEEPSEEK_MODEL,
+      apiKey: env.LLM_API_KEY || env.DEEPSEEK_API_KEY,
+    };
+  }
+  return {
+    provider: "mimo",
+    baseUrl: env.LLM_BASE_URL || env.MIMO_BASE_URL || DEFAULT_MIMO_BASE_URL,
+    model: env.LLM_MODEL || env.MIMO_MODEL || DEFAULT_MIMO_MODEL,
+    apiKey: env.LLM_API_KEY || env.MIMO_API_KEY,
+  };
+}
+
+async function callOpenAiCompatible(llm, prompt) {
+  if (!llm.apiKey) throw new Error(`missing_${llm.provider}_api_key`);
+  const response = await fetch(`${normalizeBaseUrl(llm.baseUrl)}/chat/completions`, {
     method: "POST",
     headers: {
       "content-type": "application/json",
-      authorization: `Bearer ${env.DEEPSEEK_API_KEY}`,
+      authorization: `Bearer ${llm.apiKey}`,
     },
     body: JSON.stringify({
-      model,
+      model: llm.model,
       temperature: 0.1,
       max_tokens: 600,
+      response_format: { type: "json_object" },
       messages: [
-        { role: "system", content: "You are a terse product intent classifier. Output JSON only." },
+        {
+          role: "system",
+          content: [
+            "You are a terse product intent classifier.",
+            "Return exactly one valid JSON object.",
+            "Do not use markdown, code fences, comments, or prose.",
+            "Use only enum values supplied by the user.",
+          ].join(" "),
+        },
         { role: "user", content: prompt },
       ],
     }),
   });
-  if (!response.ok) throw new Error(`deepseek_http_${response.status}`);
+  if (!response.ok) throw new Error(`${llm.provider}_http_${response.status}`);
   const data = await response.json();
-  const content = data?.choices?.[0]?.message?.content;
-  if (typeof content !== "string" || !content.trim()) throw new Error("deepseek_empty_content");
+  if (data?.error) throw new Error(`${llm.provider}_error_${data.error.code || data.error.type || "unknown"}`);
+  const content = extractOpenAiCompatibleContent(data);
+  if (typeof content !== "string" || !content.trim()) throw new Error(`${llm.provider}_empty_content`);
   return content;
 }
 
+function normalizeBaseUrl(baseUrl) {
+  return String(baseUrl || "").replace(/\/+$/, "");
+}
+
+function extractOpenAiCompatibleContent(data) {
+  const choice = data?.choices?.[0];
+  const message = choice?.message || {};
+  const content = message.content;
+  if (typeof content === "string" && content.trim()) return content;
+  if (Array.isArray(content)) {
+    const text = content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (typeof part?.text === "string") return part.text;
+        if (typeof part?.content === "string") return part.content;
+        return "";
+      })
+      .join("");
+    if (text.trim()) return text;
+  }
+  if (typeof message.reasoning_content === "string" && message.reasoning_content.trim()) return message.reasoning_content;
+  if (typeof choice?.text === "string" && choice.text.trim()) return choice.text;
+  if (typeof data?.output_text === "string" && data.output_text.trim()) return data.output_text;
+  return "";
+}
+
 function extractJson(text) {
   try {
     return JSON.parse(text);
   } catch {
-    const start = text.indexOf("{");
-    const end = text.lastIndexOf("}");
-    if (start < 0 || end <= start) return null;
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced) {
+      try {
+        return JSON.parse(fenced[1]);
+      } catch {
+        // Continue to balanced object extraction below.
+      }
+    }
+    const candidate = extractFirstBalancedObject(text);
+    if (!candidate) return null;
     try {
-      return JSON.parse(text.slice(start, end + 1));
+      return JSON.parse(candidate);
     } catch {
       return null;
     }
   }
 }
 
+function extractFirstBalancedObject(text) {
+  const start = text.indexOf("{");
+  if (start < 0) return "";
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i += 1) {
+    const char = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === "\"") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "\"") {
+      inString = true;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") depth -= 1;
+    if (depth === 0) return text.slice(start, i + 1);
+  }
+  return "";
+}
+
 function sanitizeDecision(raw) {
   if (!raw || typeof raw !== "object") return null;
   const bestGate = raw.bestGate || raw.needType;

package/workers/wrangler.toml.example

@@ -2,18 +2,23 @@ name = "product-spec-pm-intent-gate"
 main = "pm-intent-gate.mjs"
 compatibility_date = "2026-06-23"
 
-kv_namespaces = [
-  { binding = "PROMPT_CACHE", id = "replace-with-kv-namespace-id" }
-]
+[[kv_namespaces]]
+binding = "PROMPT_CACHE"
+id = "replace-with-kv-namespace-id"
 
-d1_databases = [
-  { binding = "PROMPT_SAMPLES", database_name = "product-spec-prompt-samples", database_id = "replace-with-d1-database-id" }
-]
+[[d1_databases]]
+binding = "PROMPT_SAMPLES"
+database_name = "product-spec-prompt-samples"
+database_id = "replace-with-d1-database-id"
 
 [vars]
-DEEPSEEK_MODEL = "deepseek-chat"
+LLM_PROVIDER = "mimo"
+LLM_BASE_URL = "https://token-plan-cn.xiaomimimo.com/v1"
+LLM_MODEL = "mimo-v2.5"
 
 # Secrets to set with wrangler:
 # wrangler secret put GATE_TOKEN
+# wrangler secret put MIMO_API_KEY
+# Optional fallback/switch later:
 # wrangler secret put DEEPSEEK_API_KEY
 # wrangler secret put RATE_LIMIT_SALT