@kontextmind/kxm 0.7.17 → 0.7.19

package/plugins/kxm/src/extension.ts

@@ -1,15 +1,24 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { dirname, join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { AGENT_COMMANDS, enforceToolPolicy } from "./commands.ts";
 import { HubClient, HubHttpError } from "./client.ts";
+import { loadKxmConfig } from "./config.ts";
+import { ensureHubRunning, hubAutoStartMode } from "./hub-autostart.ts";
+import { readHubEnvRecord } from "./hub-env.ts";
+import { defaultProjectName } from "./project-name.ts";
 import { nousFactoryWork, type NousRegistrationReport } from "./nous-pi.ts";
 import {
   antigravityRegistrationNotice,
   registerAntigravityProvider,
   type AntigravityRegistration,
 } from "./providers/antigravity/register.ts";
+import {
+  claudeBridgeRegistrationNotice,
+  registerClaudeBridgeProvider,
+  type ClaudeBridgeRegistration,
+} from "./providers/claude-bridge/register.ts";
 import { areaForTool, classifyFailure, diagnosticEvidence, diagnosticSummary, type Diagnostic } from "./diagnostics.ts";
 import {
   MAX_CONTENT_CHARS,
@@ -166,6 +175,7 @@ export default function piMeshExtension(pi: ExtensionAPI): void | Promise<void>
   let client: HubClient | undefined;
   let nousReport: NousRegistrationReport | undefined;
   let antigravityReport: AntigravityRegistration | undefined;
+  let claudeBridgeReport: ClaudeBridgeRegistration | undefined;
   let pending: MessageRecord[] = [];
   let activatingInbound: MessageRecord | undefined;
   let awaitingActivation: MessageRecord | undefined;
@@ -648,6 +658,8 @@ export default function piMeshExtension(pi: ExtensionAPI): void | Promise<void>
     shuttingDown = false;
     const antigravityNotice = antigravityRegistrationNotice(antigravityReport, pi);
     if (antigravityNotice) ctx.ui.notify(antigravityNotice.message, antigravityNotice.type);
+    const claudeBridgeNotice = claudeBridgeRegistrationNotice(claudeBridgeReport, pi);
+    if (claudeBridgeNotice) ctx.ui.notify(claudeBridgeNotice.message, claudeBridgeNotice.type);
     if (nousReport?.guidance.length) {
       for (const item of nousReport.guidance) {
         ctx.ui.notify(item.message, item.level);
@@ -665,7 +677,7 @@ export default function piMeshExtension(pi: ExtensionAPI): void | Promise<void>
     }
     currentPiSessionId = ctx.sessionManager?.getSessionId();
     const serverUrl = process.env.KXM_SERVER_URL ?? "http://127.0.0.1:7331";
-    const project = process.env.KXM_PROJECT ?? basename(ctx.cwd);
+    const project = defaultProjectName(ctx.cwd, process.env);
     const name = process.env.KXM_AGENT_NAME ?? pi.getSessionName() ?? `pi-${process.pid}`;
     agentName = name;
     projectName = project;
@@ -673,12 +685,42 @@ export default function piMeshExtension(pi: ExtensionAPI): void | Promise<void>
     removeMatchingLegacyRecoveryContext();
     const purpose = process.env.KXM_AGENT_PURPOSE ?? "General-purpose coding agent";
     const model = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
+    let autoStartToken: string | undefined;
+    try {
+      const config = loadKxmConfig(ctx.cwd);
+      if (hubAutoStartMode(config) === "background") {
+        const ensured = await ensureHubRunning({ config, cwd: ctx.cwd });
+        if (ensured.status === "started") {
+          autoStartToken = ensured.authToken;
+          ctx.ui.notify(
+            `kxm hub started in the background (pid ${ensured.pid}); logs: ${ensured.logPath}`
+              + (ensured.authTokenSource === "generated" ? "; new admin token generated and persisted to user state" : ""),
+            "info",
+          );
+        } else if (ensured.status === "failed") {
+          ctx.ui.notify(`kxm hub auto-start failed: ${ensured.reason} (log: ${ensured.logPath})`, "warning");
+        }
+      }
+    } catch (error) {
+      ctx.ui.notify(`kxm hub auto-start failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
+    }
+    // Authenticate with the explicit env token first, then the token resolved
+    // by auto-start, then the credential persisted for this machine's hubs.
+    const envAuthToken = process.env.KXM_AUTH_TOKEN?.trim();
+    let hubAuthToken = envAuthToken || autoStartToken;
+    if (!hubAuthToken) {
+      try {
+        hubAuthToken = readHubEnvRecord()?.authToken?.trim() || undefined;
+      } catch (error) {
+        ctx.ui.notify(`kxm could not read persisted hub credentials: ${error instanceof Error ? error.message : String(error)}`, "warning");
+      }
+    }
     client = new HubClient({
       serverUrl,
       name,
       purpose,
       project,
-      ...(process.env.KXM_AUTH_TOKEN ? { authToken: process.env.KXM_AUTH_TOKEN } : {}),
+      ...(hubAuthToken ? { authToken: hubAuthToken } : {}),
       ...(model ? { model } : {}),
     });
     notify = (message, type) => ctx.ui.notify(message, type);
@@ -933,6 +975,7 @@ export default function piMeshExtension(pi: ExtensionAPI): void | Promise<void>
   });
 
   antigravityReport = registerAntigravityProvider(pi);
+  claudeBridgeReport = registerClaudeBridgeProvider(pi);
   return nousFactoryWork(pi, (report) => {
     nousReport = report;
   });

package/plugins/kxm/src/hub-autostart.ts

@@ -0,0 +1,214 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { probeHubHealth, readHubBinding } from "./hub-binding.ts";
+import { resolveHubCredentials } from "./hub-env.ts";
+import { redactSecrets } from "./redact.ts";
+
+/** Background hub auto-start for harness extensions (Pi TUI, one-shot CLIs).
+ *
+ * On extension load: reuse a healthy bound hub, then a live local `hub.pid`
+ * claim, and only then spawn the detached `kxm-hub.mjs` wrapper. Credentials
+ * are resolved before launch, so a first run generates the admin token and
+ * persists it (`0600`) under the user state root, exactly as
+ * `kxm hub start` does. The single-hub-per-user invariants (exclusive PID
+ * claim, reclaimed dead wrappers) come from the wrapper itself. */
+
+export const HUB_AUTOSTART_LOG_NAME = "hub-autostart.log";
+const CLAIM_POLL_MS = 50;
+const DEFAULT_CLAIM_TIMEOUT_MS = 3000;
+
+export type HubAutoStartMode = "off" | "background";
+
+export type EnsureHubResult =
+  | { status: "disabled" }
+  | { status: "bound-healthy"; url: string }
+  | { status: "url-healthy"; url: string }
+  | { status: "claim-alive"; pid: number }
+  | { status: "started"; pid: number; logPath: string; authToken: string | undefined; authTokenSource: string }
+  | { status: "failed"; reason: string; logPath: string };
+
+export interface HubSpawnOptions {
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  stdio: ["ignore", number, number];
+  detached: boolean;
+  windowsHide: boolean;
+}
+
+export interface HubSpawned {
+  pid?: number | undefined;
+  once(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
+}
+
+export type HubSpawner = (command: string, args: readonly string[], options: HubSpawnOptions) => HubSpawned;
+
+export interface EnsureHubOptions {
+  config: { hub?: { autoStart?: unknown } } | undefined;
+  cwd: string;
+  env?: NodeJS.ProcessEnv | undefined;
+  fetchImpl?: typeof fetch | undefined;
+  spawner?: HubSpawner | undefined;
+  processExists?: ((pid: number) => boolean) | undefined;
+  scriptPath?: string | undefined;
+  sleep?: ((ms: number) => Promise<void>) | undefined;
+  now?: (() => number) | undefined;
+  claimTimeoutMs?: number | undefined;
+}
+
+/** Resolve the configured auto-start mode; unknown values fail closed to the
+ * default so a typo never silently disables (or re-enables) hub startup. */
+export function hubAutoStartMode(config: { hub?: { autoStart?: unknown } } | undefined): HubAutoStartMode {
+  const raw = config?.hub?.autoStart;
+  return raw === "off" || raw === "background" ? raw : "background";
+}
+
+function defaultProcessExists(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+export interface HubClaimSnapshot {
+  pid: number;
+  serverPid: number | undefined;
+}
+
+/** Read the workspace hub PID claim. A missing or malformed claim is not
+ * live; the wrapper fails closed on malformed claims when it starts, so the
+ * extension must not try to clean claims up itself. */
+export function readLiveHubClaim(stateDir: string, processExists: (pid: number) => boolean = defaultProcessExists): HubClaimSnapshot | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(join(stateDir, "hub.pid"), "utf8"));
+  } catch {
+    return undefined;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+  const record = parsed as { version?: unknown; role?: unknown; pid?: unknown; serverPid?: unknown };
+  if (record.version !== 1 || record.role !== "hub" || !Number.isInteger(record.pid)) return undefined;
+  const pid = record.pid as number;
+  if (pid <= 0 || !processExists(pid)) return undefined;
+  return {
+    pid,
+    ...(Number.isInteger(record.serverPid) && (record.serverPid as number) > 0 ? { serverPid: record.serverPid as number } : { serverPid: undefined }),
+  };
+}
+
+/** The hub wrapper script next to the checked-out KXM repo. The extension and
+ * the CLI both resolve the same path so auto-start launches the identical
+ * supervision wrapper as `kxm hub start`. */
+export function defaultHubWrapperScriptPath(moduleUrl: string = import.meta.url): string {
+  return resolve(dirname(fileURLToPath(moduleUrl)), "../../../scripts/kxm-hub.mjs");
+}
+
+function defaultHubSpawner(command: string, args: readonly string[], options: HubSpawnOptions): HubSpawned {
+  const child = spawn(command, [...args], options);
+  child.unref();
+  return child;
+}
+
+function logTail(logPath: string, maxChars = 2000): string {
+  try {
+    return redactSecrets(readFileSync(logPath, "utf8").trim().slice(-maxChars));
+  } catch {
+    return "";
+  }
+}
+
+/** Ensure a hub is available, starting a detached one only when no healthy
+ * bound hub and no live local claim exists. Never throws for ordinary
+ * failures; structured results let callers notify without blocking load. */
+export async function ensureHubRunning(options: EnsureHubOptions): Promise<EnsureHubResult> {
+  const env = options.env ?? process.env;
+  if (hubAutoStartMode(options.config) !== "background") return { status: "disabled" };
+
+  // 1. A bound hub that answers health is authoritative — reuse it.
+  const binding = readHubBinding(env);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  if (binding) {
+    const { health } = await probeHubHealth(binding.url, fetchImpl);
+    if (health === "on") return { status: "bound-healthy", url: binding.url };
+  }
+
+  // 2. A live local claim means a hub (started any way) already owns this
+  //    workspace state — do not start a second one.
+  const workdir = resolve(env.KXM_WORKDIR?.trim() || options.cwd);
+  const workspaceDir = resolve(workdir, env.KXM_WORKSPACE_DIR?.trim() || ".kxm");
+  const stateDir = resolve(workdir, env.KXM_STATE_DIR?.trim() || join(workspaceDir, "state"));
+  const logsDir = resolve(workdir, env.KXM_LOGS_DIR?.trim() || join(workspaceDir, "logs"));
+  const processExists = options.processExists ?? defaultProcessExists;
+  const live = readLiveHubClaim(stateDir, processExists);
+  if (live) return { status: "claim-alive", pid: live.pid };
+
+  // 3. A hub already serving the configured URL (for example one launched
+  //    directly by a harness, without a claim or binding) is reused too: the
+  //    client will connect there regardless, so spawning a duplicate would
+  //    only fail to bind the same port.
+  const serverUrl = (env.KXM_SERVER_URL?.trim() || "http://127.0.0.1:7331").replace(/\/+$/, "");
+  if (serverUrl !== binding?.url) {
+    const { health } = await probeHubHealth(serverUrl, fetchImpl);
+    if (health === "on") return { status: "url-healthy", url: serverUrl };
+  }
+
+  // 4. Resolve credentials before launch so the key exists by the time the
+  //    wrapper starts: env wins, then the persisted user-state file, then a
+  //    generated token persisted with 0600 for later restarts and workers.
+  const credentials = resolveHubCredentials({ env });
+  const logPath = join(logsDir, HUB_AUTOSTART_LOG_NAME);
+  mkdirSync(logsDir, { recursive: true });
+  const logFd = openSync(logPath, "a");
+  let child: HubSpawned;
+  try {
+    child = (options.spawner ?? defaultHubSpawner)(process.execPath, [options.scriptPath ?? defaultHubWrapperScriptPath()], {
+      cwd: workdir,
+      env: {
+        ...env,
+        KXM_WORKDIR: workdir,
+        KXM_WORKSPACE_DIR: workspaceDir,
+        KXM_STATE_DIR: stateDir,
+        KXM_LOGS_DIR: logsDir,
+        ...(credentials.authToken ? { KXM_AUTH_TOKEN: credentials.authToken } : {}),
+      },
+      stdio: ["ignore", logFd, logFd],
+      detached: process.platform !== "win32",
+      windowsHide: true,
+    });
+  } finally {
+    closeSync(logFd);
+  }
+
+  // 4. Verify the wrapper claimed the hub. A simultaneous loader may have won
+  //    the exclusive claim first; that is a live hub, not a failure.
+  const sleep = options.sleep ?? ((ms: number) => new Promise<void>((resolveSleep) => setTimeout(resolveSleep, ms)));
+  const now = options.now ?? Date.now;
+  const timeoutMs = options.claimTimeoutMs ?? DEFAULT_CLAIM_TIMEOUT_MS;
+  let earlyExit: { code: number | null; signal: NodeJS.Signals | null } | undefined;
+  child.once("exit", (code, signal) => {
+    earlyExit = { code, signal };
+  });
+  const deadline = now() + timeoutMs;
+  for (;;) {
+    if (earlyExit) {
+      // A simultaneous loader may have won the exclusive claim first; that
+      // is a live hub, not a failure.
+      const raced = readLiveHubClaim(stateDir, processExists);
+      if (raced) return { status: "claim-alive", pid: raced.pid };
+      const detail = logTail(logPath);
+      const reason = `hub wrapper exited before claiming the hub (code ${earlyExit.code ?? "null"}${earlyExit.signal ? `, signal ${earlyExit.signal}` : ""})${detail ? `: ${detail}` : ""}`;
+      return { status: "failed", reason, logPath };
+    }
+    const claimed = readLiveHubClaim(stateDir, processExists);
+    if (claimed) return { status: "started", pid: claimed.pid, logPath, authToken: credentials.authToken, authTokenSource: credentials.authTokenSource };
+    if (now() >= deadline) {
+      return child.pid
+        ? { status: "started", pid: child.pid, logPath, authToken: credentials.authToken, authTokenSource: credentials.authTokenSource }
+        : { status: "failed", reason: `hub wrapper did not claim the hub within ${timeoutMs} ms`, logPath };
+    }
+    await sleep(CLAIM_POLL_MS);
+  }
+}

package/plugins/kxm/src/mcp-server.ts

@@ -1,13 +1,13 @@
-import { basename } from "node:path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { HubClient } from "./client.ts";
+import { defaultProjectName } from "./project-name.ts";
 import { AGENT_COMMANDS_MAP, enforceToolPolicy, getMcpTools, reconcileInbox } from "./commands.ts";
 import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 
-const VERSION = "0.7.17";
+const VERSION = "0.7.19";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();
 let meshClient: HubClient | undefined;
@@ -88,7 +88,7 @@ async function ensureClient(): Promise<HubClient> {
       serverUrl: process.env.KXM_SERVER_URL?.trim() || "http://127.0.0.1:7331",
       name: process.env.KXM_AGENT_NAME?.trim() || `claude-${process.pid}`,
       purpose: process.env.KXM_AGENT_PURPOSE?.trim() || "Claude Code implementation and review agent",
-      project: process.env.KXM_PROJECT?.trim() || basename(projectDir),
+      project: defaultProjectName(projectDir, process.env),
       model: "claude-code",
       ...(authToken ? { authToken } : {}),
     });

package/plugins/kxm/src/project-name.ts

@@ -0,0 +1,20 @@
+import { readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+/** Default project identity for a workspace.
+ *
+ * Precedence: `KXM_PROJECT` environment, then the workspace `package.json`
+ * `name`, then the workspace directory name. The package.json read is
+ * best-effort and never walks upward: a missing, malformed, or name-less
+ * file falls through to the directory name. */
+export function defaultProjectName(cwd: string, env: NodeJS.ProcessEnv = process.env): string {
+  const fromEnv = env.KXM_PROJECT?.trim();
+  if (fromEnv) return fromEnv;
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8")) as { name?: unknown };
+    if (typeof pkg.name === "string" && pkg.name.trim().length > 0) return pkg.name.trim();
+  } catch {
+    // No readable package.json: fall through to the directory name.
+  }
+  return basename(cwd);
+}

package/plugins/kxm/src/providers/claude-bridge/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eli Dickinson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/plugins/kxm/src/providers/claude-bridge/README.md

@@ -0,0 +1,18 @@
+# Claude-bridge provider (vendored)
+
+Provider-only subset of `pi-claude-bridge` 0.7.0, built into the kxm plugin.
+
+- Upstream: [elidickinson/pi-claude-bridge](https://github.com/elidickinson/pi-claude-bridge)
+- npm: `pi-claude-bridge@0.7.0`
+- License: MIT, Copyright (c) 2026 Eli Dickinson — see `LICENSE`
+- Author: Eli Dickinson
+
+The Pi provider id remains `claude-bridge` so existing `claude login` /
+subscription credentials carry over. This slice vendors model registration
+(Opus/Sonnet/Haiku/Fable ids the plugin actually registers), Anthropic Agent
+SDK streaming, thinking/effort mapping, and the in-process MCP bridge that
+exposes Pi tools to Claude Code.
+
+Not vendored here: the AskClaude tool, user-facing MCP/UI panels, TUI extras,
+session JSONL rebuild (`cc-session-io`), and skills/prompt-capture forwarding.
+No `@earendil-works/pi-ai` import.

package/plugins/kxm/src/providers/claude-bridge/config.ts

@@ -0,0 +1,53 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { LongContextSettings } from "./models.ts";
+
+export interface ClaudeBridgeConfig {
+  provider?: {
+    strictMcpConfig?: boolean;
+    autoMemoryEnabled?: boolean;
+    pathToClaudeCodeExecutable?: string;
+    plan?: "pro" | "max";
+    longContextExtraUsage?: boolean;
+  };
+}
+
+export function tryParseJson(path: string): Partial<ClaudeBridgeConfig> {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as Partial<ClaudeBridgeConfig>;
+  } catch (error) {
+    console.error(`claude-bridge: failed to parse ${path}: ${error}`);
+    return {};
+  }
+}
+
+export function globalConfigPath(home = homedir()): string {
+  return join(home, ".pi", "agent", "claude-bridge.json");
+}
+
+export function projectConfigPath(cwd: string): string {
+  return join(cwd, ".pi", "claude-bridge.json");
+}
+
+export function loadConfig(cwd: string, home = homedir()): ClaudeBridgeConfig {
+  const global = tryParseJson(globalConfigPath(home));
+  const project = tryParseJson(projectConfigPath(cwd));
+  return {
+    provider: { ...global.provider, ...project.provider },
+  };
+}
+
+export function longContextFromConfig(config: ClaudeBridgeConfig): LongContextSettings {
+  return {
+    plan: config.provider?.plan === "max" ? "max" : "pro",
+    longContextExtraUsage: Boolean(config.provider?.longContextExtraUsage),
+  };
+}
+
+export function claudeCodeSettings(provider: ClaudeBridgeConfig["provider"] = {}): {
+  autoMemoryEnabled: boolean;
+} {
+  return { autoMemoryEnabled: provider.autoMemoryEnabled ?? false };
+}

package/plugins/kxm/src/providers/claude-bridge/convert.ts

@@ -0,0 +1,180 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+import type { ImageContent, Message, TextContent, UserMessage } from "./pi-compat.ts";
+import { PROVIDER_ID } from "./models.ts";
+import { MCP_TOOL_PREFIX, mapPiToolNameToSdk, sanitizeToolId } from "./tools.ts";
+
+export { PROVIDER_ID };
+
+export function messageContentToText(
+  content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  let hasText = false;
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      parts.push(block.text);
+      hasText = true;
+    } else if (block.type !== "text" && block.type !== "image") {
+      parts.push(`[${block.type}]`);
+    }
+  }
+  return hasText ? parts.join("\n") : "";
+}
+
+function toolResultContent(
+  content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string | Array<Record<string, unknown>> {
+  if (typeof content === "string" || !Array.isArray(content)) return messageContentToText(content) || "";
+  const images = content.filter((b) => b.type === "image" && b.data && b.mimeType);
+  if (!images.length) return messageContentToText(content) || "";
+  const blocks: Array<Record<string, unknown>> = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+    else if (block.type === "image" && block.data && block.mimeType) {
+      blocks.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+    } else if (block.type !== "text" && block.type !== "image") {
+      blocks.push({ type: "text", text: `[${block.type}]` });
+    }
+  }
+  return blocks;
+}
+
+export type DroppedContent = {
+  thinking: number;
+  abortedTurns: number;
+  providers: Set<string>;
+  other: Map<string, number>;
+};
+
+export type AnthropicMessage = { role: string; content: unknown };
+
+export function convertPiMessages(
+  messages: Message[],
+  customToolNameToSdk?: Map<string, string>,
+): { anthropicMessages: AnthropicMessage[]; sanitizedIds: Map<string, string>; dropped: DroppedContent } {
+  const anthropicMessages: AnthropicMessage[] = [];
+  const sanitizedIds = new Map<string, string>();
+  const dropped: DroppedContent = { thinking: 0, abortedTurns: 0, providers: new Set(), other: new Map() };
+  let turnResults: { role: "user"; content: Array<Record<string, unknown>> } | null = null;
+  let turnAssistantIdx: number | null = null;
+
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        anthropicMessages.push({ role: "user", content: msg.content || "[empty]" });
+      } else if (Array.isArray(msg.content)) {
+        const parts = [];
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
+          else if (block.type === "image" && block.data && block.mimeType) {
+            parts.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+          }
+        }
+        anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+      } else {
+        anthropicMessages.push({ role: "user", content: "[empty]" });
+      }
+    } else if (msg.role === "assistant") {
+      const content = Array.isArray(msg.content) ? msg.content : [];
+      const blocks = [];
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          blocks.push({ type: "text", text: block.text });
+        } else if (block.type === "thinking") {
+          const sig = block.thinkingSignature;
+          if (msg.provider === PROVIDER_ID && sig) {
+            blocks.push({ type: "thinking", thinking: block.thinking ?? "", signature: sig });
+          } else {
+            dropped.thinking++;
+            dropped.providers.add(msg.provider ?? "unknown");
+          }
+        } else if (block.type === "toolCall") {
+          const toolName = mapPiToolNameToSdk(block.name, customToolNameToSdk);
+          blocks.push({
+            type: "tool_use",
+            id: sanitizeToolId(block.id, sanitizedIds),
+            name: toolName,
+            input: block.arguments ?? {},
+          });
+        } else {
+          dropped.other.set(block.type, (dropped.other.get(block.type) ?? 0) + 1);
+        }
+      }
+      if (!content.length) {
+        dropped.abortedTurns++;
+        continue;
+      }
+      if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
+      turnResults = null;
+      turnAssistantIdx = anthropicMessages.length;
+      anthropicMessages.push({ role: "assistant", content: blocks });
+    } else if (msg.role === "toolResult") {
+      const block = {
+        type: "tool_result",
+        tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds),
+        content: toolResultContent(msg.content),
+        is_error: msg.isError,
+      };
+      if (turnResults) {
+        turnResults.content.push(block);
+      } else {
+        turnResults = { role: "user", content: [block] };
+        anthropicMessages.splice(turnAssistantIdx === null ? anthropicMessages.length : turnAssistantIdx + 1, 0, turnResults);
+      }
+    }
+  }
+
+  return { anthropicMessages, sanitizedIds, dropped };
+}
+
+export function turnStart(messages: Message[]): number {
+  let i = messages.length;
+  while (i > 0 && messages[i - 1].role === "user") i--;
+  return i;
+}
+
+export function extractUserPrompt(messages: Message[]): string | null {
+  const turn = messages.slice(turnStart(messages)) as UserMessage[];
+  if (turn.length === 0) return null;
+  return turn
+    .map((m) => (typeof m.content === "string" ? m.content : messageContentToText(m.content)))
+    .filter((text) => text)
+    .join("\n");
+}
+
+export function extractUserPromptBlocks(
+  messages: Message[],
+): Array<{ type: "text"; text: string } | { type: "image"; source: { type: "base64"; media_type: string; data: string } }> | null {
+  const turn = messages.slice(turnStart(messages)) as UserMessage[];
+  if (turn.length === 0) return null;
+  let hasImage = false;
+  const blocks = [];
+  for (const message of turn) {
+    const content: Array<TextContent | ImageContent> =
+      typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+    if (!Array.isArray(content)) {
+      throw new Error(
+        `extractUserPromptBlocks: user message content must be a string or block array, got ${typeof content}`,
+      );
+    }
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        blocks.push({ type: "text", text: block.text });
+      } else if (block.type === "image") {
+        if (!block.data || !block.mimeType) continue;
+        hasImage = true;
+        blocks.push({
+          type: "image",
+          source: { type: "base64" as const, media_type: block.mimeType, data: block.data },
+        });
+      }
+    }
+  }
+  return hasImage ? blocks : null;
+}
+
+export function alreadySdkToolName(name: string): boolean {
+  return name.toLowerCase().startsWith(MCP_TOOL_PREFIX);
+}

package/plugins/kxm/src/providers/claude-bridge/index.ts

@@ -0,0 +1,28 @@
+export {
+  CLAUDE_BRIDGE_API,
+  CLAUDE_BRIDGE_MODELS,
+  MODEL_IDS_IN_ORDER,
+  PROVIDER_ID,
+  PROVIDER_NAME,
+  applyLongContext,
+  claudeCodeModelId,
+  registeredClaudeBridgeModels,
+  resolveClaudeCodeRuntimeModel,
+  resolveEffort,
+  resolveModel,
+  REASONING_TO_EFFORT,
+} from "./models.ts";
+export {
+  CLAUDE_BRIDGE_DOUBLE_REGISTRATION_WARNING,
+  CLAUDE_BRIDGE_HOST_PROBE_METHODS,
+  STANDALONE_CLAUDE_BRIDGE_TOOLS,
+  claudeBridgeRegistrationNotice,
+  claudeBridgeStandaloneToolsPresent,
+  registerClaudeBridgeProvider,
+  shouldSkipClaudeBridgeRegistration,
+  type ClaudeBridgeRegistration,
+} from "./register.ts";
+export { consumeQuery, processAssistantMessage, processStreamEvent } from "./stream.ts";
+export { streamClaudeBridge, resetClaudeBridgeSession } from "./provider.ts";
+export { convertPiMessages } from "./convert.ts";
+export { looksLikeClaudeBridgeSecret, redactClaudeBridgeSecrets } from "./redact.ts";