@liy/mote-pi-runtime 0.3.0

package/dist/extensions/mote-mcp.js

@@ -0,0 +1,32 @@
+// assets/mote-mcp.ts
+var adapterModuleName = "pi-mcp-adapter";
+var { createMcpAdapter } = await import(adapterModuleName);
+var registerMoteMcpAdapter = createMcpAdapter({
+  // Mote owns this fixed local transport. Keeping it programmatic prevents a
+  // writable Pi session from becoming a source of MCP routing configuration.
+  config: {
+    // Widget data may exceed the adapter's 50 KiB model-text limit. Preserve
+    // the full structured result for timeline replay while retaining that text
+    // guard. A 192 KiB widget fits even with MCP's escaped text duplicate.
+    settings: {
+      directToolResultDetails: "bounded",
+      outputGuard: { detailsMaxBytes: 1024 * 1024 }
+    },
+    mcpServers: {
+      mote: {
+        command: "orchestrator",
+        args: ["mcp", "mote"],
+        protocolVersion: "2026-07-28",
+        // Cards require the native structured tool result. A scripting wrapper
+        // can omit it or print it as prose before Pi emits the message.
+        directTools: ["propose_action", "render_inline_widget"]
+      }
+    }
+  }
+});
+function registerMoteMcp(pi) {
+  registerMoteMcpAdapter(pi);
+}
+export {
+  registerMoteMcp as default
+};

package/dist/extensions/mote-prompt-composer.js

@@ -0,0 +1,44 @@
+// assets/mote-prompt-composer.ts
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var INSTRUCTIONS = {
+  en: {
+    language: "Reply concisely in English, even when history or tools use another language. Preserve code, identifiers and necessary quotations.",
+    sources: "Connected sources first: look for relevant data in the user's authorized MCP tools, files, devices, and services before searching the web. Use the web to fill gaps or when explicitly requested.",
+    assessment: "Assess ticket outcomes using the orchestrator skill. Start with orchestrator ticket brief; use ticket worklog for authored context and targeted ticket timeline pages for evidence. Decide the next assignment, gatekeeper review, parking or completion from the evidence. Delegate implementation and validation; do not repeat that work yourself. Assign a different agent to gatekeep completed work. Finish after recording your decisions; do not wait or poll for agents.",
+    ticket: "Use the orchestrator skill and orchestrator ticket brief to read the assigned ticket and its current context. Complete only the assigned work and report the outcome, evidence and any blocker concisely. Do not assign agents or change ticket lifecycle state. When assigned as gatekeeper, review against the requirements and integrate app changes only after they pass. Never gatekeep your own work. Before ending the assignment, submit orchestrator ticket handoff with results, validation, remainingWork, and optional evidence references. Report incomplete work honestly; a final response does not replace the handoff command. Finish your turn when the assignment is complete or blocked."
+  },
+  "zh-CN": {
+    language: "\u4F7F\u7528\u7B80\u4F53\u4E2D\u6587\u7B80\u6D01\u56DE\u590D\uFF0C\u5373\u4F7F\u5386\u53F2\u6D88\u606F\u6216\u5DE5\u5177\u5185\u5BB9\u4F7F\u7528\u5176\u4ED6\u8BED\u8A00\u3002\u4FDD\u7559\u4EE3\u7801\u3001\u6807\u8BC6\u7B26\u548C\u5FC5\u8981\u7684\u539F\u6587\u5F15\u7528\u3002",
+    sources: "\u5DF2\u8FDE\u63A5\u7684\u6570\u636E\u6E90\u4F18\u5148\uFF1A\u5148\u4ECE\u7528\u6237\u5DF2\u6388\u6743\u7684 MCP \u5DE5\u5177\u3001\u6587\u4EF6\u3001\u8BBE\u5907\u548C\u670D\u52A1\u4E2D\u67E5\u627E\u76F8\u5173\u6570\u636E\uFF0C\u518D\u641C\u7D22\u7F51\u9875\u3002\u9700\u8981\u8865\u5145\u4FE1\u606F\u6216\u7528\u6237\u660E\u786E\u8981\u6C42\u65F6\uFF0C\u4F7F\u7528\u7F51\u9875\u641C\u7D22\u3002",
+    assessment: "\u4F7F\u7528 orchestrator \u6280\u80FD\uFF0C\u5148\u8BFB\u53D6 orchestrator ticket brief\uFF0C\u901A\u8FC7 ticket worklog \u83B7\u53D6\u8865\u5145\u4E0A\u4E0B\u6587\uFF0C\u4EC5\u5728\u9700\u8981\u8BC1\u636E\u65F6\u8BFB\u53D6\u76F8\u5E94\u7684 ticket timeline \u9875\u9762\u3002\u4F9D\u636E\u8BC1\u636E\u8BC4\u4F30\u5DE5\u5355\u7ED3\u679C\uFF0C\u51B3\u5B9A\u4E0B\u4E00\u6B21\u5206\u914D\u3001\u9A8C\u6536\u3001\u6401\u7F6E\u6216\u5B8C\u6210\u3002\u5C06\u5B9E\u73B0\u548C\u9A8C\u8BC1\u4EA4\u7ED9\u76F8\u5E94\u4E13\u5BB6\uFF0C\u4E0D\u8981\u4EB2\u81EA\u91CD\u590D\u6267\u884C\u3002\u5DF2\u5B8C\u6210\u7684\u5DE5\u4F5C\u5E94\u4EA4\u7ED9\u53E6\u4E00\u4F4D\u4EE3\u7406\u9A8C\u6536\u3002\u8BB0\u5F55\u51B3\u7B56\u540E\u7ED3\u675F\uFF0C\u4E0D\u8981\u7B49\u5F85\u6216\u8F6E\u8BE2\u5176\u4ED6\u4EE3\u7406\u3002",
+    ticket: "\u4F7F\u7528 orchestrator \u6280\u80FD\u548C orchestrator ticket brief \u8BFB\u53D6\u6240\u5206\u914D\u7684\u5DE5\u5355\u53CA\u5176\u5F53\u524D\u4E0A\u4E0B\u6587\u3002\u4EC5\u5B8C\u6210\u6240\u5206\u914D\u7684\u5DE5\u4F5C\uFF0C\u7B80\u8981\u62A5\u544A\u7ED3\u679C\u3001\u8BC1\u636E\u53CA\u963B\u788D\u3002\u4E0D\u8981\u5206\u914D\u4EE3\u7406\u6216\u66F4\u6539\u5DE5\u5355\u751F\u547D\u5468\u671F\u72B6\u6001\u3002\u88AB\u5206\u914D\u4E3A\u9A8C\u6536\u8005\u65F6\uFF0C\u4F9D\u636E\u9700\u6C42\u5BA1\u67E5\uFF0C\u901A\u8FC7\u540E\u518D\u96C6\u6210\u5E94\u7528\u66F4\u6539\u3002\u4E0D\u5F97\u9A8C\u6536\u81EA\u5DF1\u7684\u5DE5\u4F5C\u3002\u7ED3\u675F\u4EFB\u52A1\u524D\uFF0C\u63D0\u4EA4 orchestrator ticket handoff\uFF0C\u5305\u542B results\u3001validation\u3001remainingWork \u548C\u53EF\u9009\u7684\u8BC1\u636E\u5F15\u7528\u3002\u5982\u5B9E\u62A5\u544A\u672A\u5B8C\u6210\u7684\u5DE5\u4F5C\uFF1B\u6700\u7EC8\u56DE\u590D\u4E0D\u80FD\u4EE3\u66FF\u4EA4\u63A5\u547D\u4EE4\u3002\u4EFB\u52A1\u5B8C\u6210\u6216\u53D7\u963B\u540E\u7ED3\u675F\u672C\u8F6E\u3002"
+  }
+};
+function composeMotePrompt(basePrompt, document, contextKind) {
+  const match = /^---\n([^\n]+)\n---\n([\s\S]*)$/.exec(document);
+  if (!match?.[1] || !match[2]?.trim()) throw new Error("Invalid Mote persona snapshot");
+  const metadata = JSON.parse(match[1]);
+  if (metadata.locale !== "en" && metadata.locale !== "zh-CN") throw new Error("Invalid Mote persona locale");
+  const instructions = INSTRUCTIONS[metadata.locale];
+  if (!["channel", "assessment", "ticket"].includes(contextKind)) throw new Error("Invalid Mote session context");
+  const execution = contextKind === "assessment" ? instructions.assessment : contextKind === "ticket" ? instructions.ticket : "";
+  const boundary = basePrompt.indexOf("\n\nAvailable tools:\n");
+  if (boundary < 0) throw new Error("Pi prompt is missing its tools boundary");
+  return [match[2].trim(), instructions.language, instructions.sources, execution].filter(Boolean).join("\n\n") + basePrompt.slice(boundary);
+}
+function mote_prompt_composer_default(pi) {
+  pi.on("before_agent_start", async (event) => {
+    const agentDir = process.env.PI_CODING_AGENT_DIR;
+    if (!agentDir) throw new Error("Mote agent profile directory is missing");
+    return { systemPrompt: composeMotePrompt(
+      event.systemPrompt,
+      await readFile(join(agentDir, "system_prompt.md"), "utf8"),
+      process.env.MOTE_SESSION_CONTEXT_KIND ?? ""
+    ) };
+  });
+}
+export {
+  composeMotePrompt,
+  mote_prompt_composer_default as default
+};

package/dist/extensions/mote-provider.js

@@ -0,0 +1,291 @@
+// assets/mote-provider.ts
+import { connect } from "node:net";
+import { createServer } from "node:http";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import {
+  getModels,
+  streamSimpleAnthropic as streamAnthropic,
+  streamSimpleOpenAIResponses as streamResponses,
+  streamSimpleOpenAICompletions as streamCompletions,
+  streamSimpleGoogle as streamGoogle
+} from "@earendil-works/pi-ai/compat";
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+var MAX_FRAME_BYTES = 8 * 1024 * 1024;
+var MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+var PROVIDER_STREAM_TIMEOUT_MS = 10 * 6e4;
+function registerMoteProvider(pi) {
+  registerMoteProviderWithTransport(pi, openRunConnectorStream);
+}
+function registerMoteProviderWithTransport(pi, transport) {
+  register("deepseek", "openai-responses", streamResponses, "/responses");
+  register("moonshotai", "openai-completions", streamCompletions, "/chat/completions");
+  register("openai", "openai-responses", streamResponses, "/responses");
+  register("anthropic", "anthropic-messages", streamAnthropic, "/messages");
+  register("zai", "openai-completions", streamCompletions, "/chat/completions");
+  pi.registerProvider("google", {
+    api: "google-generative-ai",
+    apiKey: "run-bound",
+    streamSimple: (model, context, options) => streamGoogleWithRelay(model, context, options, transport)
+  });
+  function register(provider, api, stream, path) {
+    pi.registerProvider(provider, {
+      api,
+      apiKey: "run-bound",
+      // Pi selects the override only when the model API matches. In particular,
+      // its DeepSeek catalog defaults to Completions; setting provider.api alone
+      // leaves those models on Pi's direct-network adapter. Keep all metadata.
+      models: getModels(provider).map((model) => ({ ...model, api })),
+      streamSimple(model, context, options) {
+        return stream({ ...model, api }, context, {
+          ...options,
+          apiKey: "run-bound",
+          transport: "sse",
+          fetch: createRunBoundFetch(provider, model.baseUrl, path, transport)
+        });
+      }
+    });
+  }
+}
+function createRunBoundFetch(provider, baseUrl, path, transport) {
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    const base = new URL(baseUrl);
+    const prefix = base.pathname.replace(/\/$/u, "");
+    if (request.method !== "POST" || url.origin !== base.origin || !url.pathname.startsWith(`${prefix}/`) || !url.pathname.endsWith(path) || url.search || url.hash) throw new Error("provider adapter attempted an unsupported route");
+    const response = await transport({
+      version: 1,
+      operation: "connector.stream",
+      alias: provider,
+      ...process.env.MOTE_AGENT_LAUNCH_ID?.trim() ? { launchId: process.env.MOTE_AGENT_LAUNCH_ID.trim() } : {},
+      method: "POST",
+      path,
+      body: JSON.parse(await request.text())
+    }, request.signal);
+    return new Response(response.body, {
+      status: response.status,
+      ...response.contentType ? { headers: { "content-type": response.contentType } } : {}
+    });
+  };
+}
+function streamGoogleWithRelay(model, context, options, transport) {
+  const result = createAssistantMessageEventStream();
+  void (async () => {
+    let relay;
+    let setupError;
+    try {
+      relay = await openGoogleRelay(model.id, transport);
+    } catch (error) {
+      setupError = error;
+    }
+    const native = streamGoogle({ ...model, baseUrl: relay?.url ?? model.baseUrl }, context, {
+      ...options,
+      apiKey: relay?.key ?? "run-bound",
+      ...relay ? {} : { onPayload: () => {
+        throw setupError;
+      } }
+    });
+    try {
+      for await (const event of native) result.push(event);
+      result.end(await native.result());
+    } finally {
+      await relay?.close();
+    }
+  })();
+  return result;
+}
+async function openGoogleRelay(modelId, transport) {
+  const key = randomBytes(32).toString("hex");
+  const keyBytes = Buffer.from(key);
+  const path = `/models/${encodeURIComponent(modelId)}:streamGenerateContent?alt=sse`;
+  const server = createServer((request, response) => {
+    void (async () => {
+      const supplied = Buffer.from(String(request.headers["x-goog-api-key"] ?? ""));
+      if (supplied.length !== keyBytes.length || !timingSafeEqual(supplied, keyBytes)) {
+        response.writeHead(403).end();
+        return;
+      }
+      if (request.method !== "POST" || request.url !== path) {
+        response.writeHead(404).end();
+        return;
+      }
+      const abort = new AbortController();
+      response.once("close", () => abort.abort());
+      const chunks = [];
+      let bytes = 0;
+      for await (const chunk of request) {
+        bytes += chunk.length;
+        if (bytes > 1024 * 1024) {
+          response.writeHead(413).end();
+          return;
+        }
+        chunks.push(chunk);
+      }
+      const upstream = await transport({
+        version: 1,
+        operation: "connector.stream",
+        alias: "google",
+        ...process.env.MOTE_AGENT_LAUNCH_ID?.trim() ? { launchId: process.env.MOTE_AGENT_LAUNCH_ID.trim() } : {},
+        method: "POST",
+        path,
+        body: JSON.parse(Buffer.concat(chunks).toString("utf8"))
+      }, abort.signal);
+      response.writeHead(upstream.status, { "content-type": upstream.contentType ?? "application/json" });
+      await pipeline(Readable.fromWeb(upstream.body), response);
+    })().catch(() => {
+      if (!response.headersSent) response.writeHead(502, { "content-type": "application/json" }).end('{"error":{"message":"provider transport failed"}}');
+      else response.destroy();
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Google relay did not bind");
+  return {
+    key,
+    url: `http://127.0.0.1:${address.port}`,
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+      server.closeAllConnections();
+    })
+  };
+}
+function openRunConnectorStream(value, signal) {
+  const socketPath = process.env.MOTE_AGENT_COMMAND_SOCKET?.trim();
+  if (!socketPath?.startsWith("/users/") || !socketPath.endsWith("/agent.sock")) {
+    return Promise.reject(new Error("agent command socket is unavailable"));
+  }
+  const requestBody = Buffer.from(JSON.stringify(value));
+  if (requestBody.byteLength === 0 || requestBody.byteLength > 1024 * 1024) {
+    return Promise.reject(new Error("provider request is too large"));
+  }
+  return new Promise((resolve, reject) => {
+    const socket = connect(socketPath);
+    let responseController;
+    const responseBody = new ReadableStream({
+      start(controller) {
+        responseController = controller;
+      },
+      cancel() {
+        socket.destroy();
+      }
+    });
+    let buffered = Buffer.alloc(0);
+    let frameLength;
+    let responseStarted = false;
+    let terminal = false;
+    let bytesRead = 0;
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    const fail = (message) => {
+      if (terminal) return;
+      terminal = true;
+      cleanup();
+      socket.destroy();
+      const error = new Error(message);
+      if (responseStarted) responseController?.error(error);
+      else reject(error);
+    };
+    const onAbort = () => fail("provider request was aborted");
+    signal?.addEventListener("abort", onAbort, { once: true });
+    socket.setTimeout(PROVIDER_STREAM_TIMEOUT_MS, () => fail("provider request timed out"));
+    socket.once("connect", () => {
+      const header = Buffer.allocUnsafe(4);
+      header.writeUInt32BE(requestBody.byteLength);
+      socket.write(Buffer.concat([header, requestBody]));
+    });
+    socket.on("data", (chunk) => {
+      buffered = Buffer.concat([buffered, chunk]);
+      while (!terminal) {
+        if (frameLength === void 0) {
+          if (buffered.byteLength < 4) return;
+          frameLength = buffered.readUInt32BE(0);
+          buffered = buffered.subarray(4);
+          if (frameLength < 1 || frameLength > MAX_FRAME_BYTES) {
+            fail("provider response frame is invalid");
+            return;
+          }
+        }
+        if (buffered.byteLength < frameLength) return;
+        const frameBody = buffered.subarray(0, frameLength);
+        buffered = buffered.subarray(frameLength);
+        frameLength = void 0;
+        let frame;
+        try {
+          frame = JSON.parse(frameBody.toString("utf8"));
+        } catch {
+          fail("provider response frame is invalid");
+          return;
+        }
+        const record = requireRecord(frame, "provider response frame");
+        if (record.type === "connector.response.start") {
+          if (responseStarted || typeof record.ok !== "boolean" || !Number.isInteger(record.status) || record.contentType !== void 0 && record.contentType !== "application/json" && record.contentType !== "text/plain" && record.contentType !== "text/event-stream") {
+            fail("provider response start frame is invalid");
+            return;
+          }
+          responseStarted = true;
+          resolve({
+            ok: record.ok,
+            status: Number(record.status),
+            ...record.contentType ? { contentType: record.contentType } : {},
+            body: responseBody
+          });
+          continue;
+        }
+        if (record.type === "connector.response.chunk") {
+          if (!responseStarted || typeof record.data !== "string") {
+            fail("provider response chunk frame is invalid");
+            return;
+          }
+          const bytes = Buffer.from(record.data, "base64");
+          bytesRead += bytes.byteLength;
+          if (bytesRead > MAX_RESPONSE_BYTES) {
+            fail("provider response is too large");
+            return;
+          }
+          responseController?.enqueue(bytes);
+          continue;
+        }
+        if (record.type === "connector.response.end") {
+          if (!responseStarted) {
+            fail("provider response ended before it started");
+            return;
+          }
+          terminal = true;
+          cleanup();
+          responseController?.close();
+          socket.end();
+          return;
+        }
+        if (record.type === "connector.response.error") {
+          const error = record.error && typeof record.error === "object" ? record.error : void 0;
+          fail(typeof error?.message === "string" ? error.message : "provider response stream failed");
+          return;
+        }
+        if (record.ok === false && record.error && typeof record.error === "object") {
+          const error = record.error;
+          fail(typeof error.message === "string" ? error.message : "provider request failed");
+          return;
+        }
+        fail("provider response frame is invalid");
+      }
+    });
+    socket.once("error", () => fail("provider channel is unavailable"));
+    socket.once("end", () => {
+      if (!terminal) fail("provider response ended early");
+    });
+  });
+}
+function requireRecord(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} is invalid`);
+  }
+  return value;
+}
+export {
+  registerMoteProvider as default,
+  registerMoteProviderWithTransport
+};