@kontextmind/kxm 0.7.17 → 0.7.19

package/plugins/kxm/src/providers/claude-bridge/mcp-server.ts

@@ -0,0 +1,59 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+// In-process MCP server that exposes pi tools to Claude Code.
+// From pi-claude-bridge 0.7.0. Not a user-facing MCP product.
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import type { McpResult } from "./tools.ts";
+
+const TOOL_USE_ID_META = "claudecode/toolUseId";
+
+export interface McpToolDef {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  handler: (toolCallId: string) => Promise<McpResult>;
+}
+
+export function assertObjectSchema(tool: McpToolDef): void {
+  const schema = tool.inputSchema as Record<string, unknown> | undefined;
+  if (!schema || schema.type !== "object") {
+    throw new Error(`${tool.name}: MCP tool parameters must be an object schema, got ${JSON.stringify(schema)}`);
+  }
+}
+
+export function createToolServer(name: string, tools: McpToolDef[]) {
+  const server = new McpServer({ name, version: "1.0.0" }, { capabilities: { tools: {} } });
+  const byName = new Map(tools.map((tool) => [tool.name, tool]));
+  for (const tool of tools) assertObjectSchema(tool);
+
+  server.server.setRequestHandler(ListToolsRequestSchema, () => ({
+    tools: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema as Record<string, unknown>,
+    })),
+  }));
+
+  server.server.setRequestHandler(CallToolRequestSchema, async (request) => dispatchToolCall(byName, request));
+
+  return { type: "sdk" as const, name, instance: server };
+}
+
+export async function dispatchToolCall(
+  byName: Map<string, McpToolDef>,
+  request: { params: { name: string; _meta?: Record<string, unknown> } },
+) {
+  const tool = byName.get(request.params.name);
+  if (!tool) throw new Error(`Unknown tool: ${request.params.name}`);
+  const toolCallId = request.params._meta?.[TOOL_USE_ID_META];
+  if (typeof toolCallId !== "string") {
+    throw new Error(
+      `${tool.name}: tools/call is missing _meta["${TOOL_USE_ID_META}"] — cannot pair the result with its tool call`,
+    );
+  }
+  const { content, isError } = await tool.handler(toolCallId);
+  return { content, isError };
+}
+
+export { TOOL_USE_ID_META };

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

@@ -0,0 +1,166 @@
+// Canonical selection + display order for the model picker.
+// Extracted from pi-claude-bridge 0.7.0; catalog is static (no pi-ai getModels).
+
+import type { Model, ProviderModelConfig, ThinkingLevel, ThinkingLevelMap } from "./pi-compat.ts";
+
+export const PROVIDER_ID = "claude-bridge";
+export const PROVIDER_NAME = "Claude Bridge";
+export const CLAUDE_BRIDGE_API = "claude-bridge";
+
+export const MODEL_IDS_IN_ORDER = [
+  "claude-fable-5-1",
+  "claude-fable-5",
+  "claude-opus-5",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-5",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+] as const;
+
+export type ClaudeBridgeModelId = (typeof MODEL_IDS_IN_ORDER)[number];
+
+const DISPLAY_NAMES: Record<ClaudeBridgeModelId, string> = {
+  "claude-fable-5-1": "Claude Fable 5.1",
+  "claude-fable-5": "Claude Fable 5",
+  "claude-opus-5": "Claude Opus 5",
+  "claude-opus-4-8": "Claude Opus 4.8",
+  "claude-opus-4-7": "Claude Opus 4.7",
+  "claude-opus-4-6": "Claude Opus 4.6",
+  "claude-sonnet-5": "Claude Sonnet 5",
+  "claude-sonnet-4-6": "Claude Sonnet 4.6",
+  "claude-haiku-4-5": "Claude Haiku 4.5",
+};
+
+/** Per-model effort overrides (pi-ai 0.72+ shipped these for later Opus). */
+const THINKING_LEVEL_MAPS: Partial<Record<ClaudeBridgeModelId, ThinkingLevelMap>> = {
+  "claude-opus-4-8": { xhigh: "xhigh", max: "max" },
+  "claude-opus-4-7": { xhigh: "xhigh", max: "max" },
+  "claude-opus-5": { xhigh: "xhigh", max: "max" },
+};
+
+export type LongContextSettings = {
+  plan: "pro" | "max";
+  longContextExtraUsage: boolean;
+};
+
+export type ClaudeCodeRuntimeModel = {
+  cliModelId: string;
+  contextWindow: number;
+};
+
+const TWO_HUNDRED_K_CONTEXT = 200_000;
+const ONE_M_CONTEXT = 1_000_000;
+
+export const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } as const;
+
+export const DEFAULT_LONG_CONTEXT: LongContextSettings = {
+  plan: "pro",
+  longContextExtraUsage: false,
+};
+
+/** Pi reasoning levels → Claude Agent SDK effort levels. */
+export const REASONING_TO_EFFORT: Record<string, string> = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max",
+};
+
+export function resolveEffort(
+  reasoning: ThinkingLevel | undefined,
+  thinkingLevelMap?: ThinkingLevelMap,
+): string | undefined {
+  if (!reasoning) return undefined;
+  const mapped = thinkingLevelMap?.[reasoning];
+  if (typeof mapped === "string") return mapped;
+  return REASONING_TO_EFFORT[reasoning];
+}
+
+export function resolveClaudeCodeRuntimeModel(
+  modelId: string,
+  settings: LongContextSettings,
+): ClaudeCodeRuntimeModel {
+  switch (modelId) {
+    case "claude-opus-5":
+      return { cliModelId: "claude-opus-5[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-opus-4-8":
+      return { cliModelId: "claude-opus-4-8[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-opus-4-7":
+      return { cliModelId: "claude-opus-4-7", contextWindow: ONE_M_CONTEXT };
+    case "claude-opus-4-6": {
+      const useOneM = settings.plan === "max" || settings.longContextExtraUsage;
+      return {
+        cliModelId: useOneM ? "claude-opus-4-6[1m]" : "claude-opus-4-6",
+        contextWindow: useOneM ? ONE_M_CONTEXT : TWO_HUNDRED_K_CONTEXT,
+      };
+    }
+    case "claude-fable-5-1":
+      return { cliModelId: "claude-fable-5-1[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-fable-5":
+      return { cliModelId: "claude-fable-5[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-sonnet-5":
+      return { cliModelId: "claude-sonnet-5[1m]", contextWindow: ONE_M_CONTEXT };
+    case "claude-sonnet-4-6":
+      return {
+        cliModelId: settings.longContextExtraUsage ? "claude-sonnet-4-6[1m]" : "claude-sonnet-4-6",
+        contextWindow: settings.longContextExtraUsage ? ONE_M_CONTEXT : TWO_HUNDRED_K_CONTEXT,
+      };
+    case "claude-haiku-4-5":
+      return { cliModelId: "claude-haiku-4-5", contextWindow: TWO_HUNDRED_K_CONTEXT };
+    default:
+      return { cliModelId: modelId, contextWindow: TWO_HUNDRED_K_CONTEXT };
+  }
+}
+
+export function claudeCodeModelId(model: { id: string }, settings: LongContextSettings): string {
+  return resolveClaudeCodeRuntimeModel(model.id, settings).cliModelId;
+}
+
+export function resolveModel<T extends { id: string }>(models: T[], input: string): T | undefined {
+  const lower = input.toLowerCase();
+  return models.find((m) => m.id === lower || m.id.includes(lower));
+}
+
+export function applyLongContext<T extends { id: string; name: string; contextWindow?: number | null }>(
+  models: T[],
+  settings: LongContextSettings,
+): T[] {
+  return models.map((m) => {
+    const { contextWindow } = resolveClaudeCodeRuntimeModel(m.id, settings);
+    const name =
+      contextWindow > TWO_HUNDRED_K_CONTEXT && !/\b1M\b/i.test(m.name) ? `${m.name} 1M` : m.name;
+    return contextWindow === m.contextWindow && name === m.name ? m : { ...m, contextWindow, name };
+  });
+}
+
+function staticModel(id: ClaudeBridgeModelId): ProviderModelConfig {
+  const runtime = resolveClaudeCodeRuntimeModel(id, DEFAULT_LONG_CONTEXT);
+  const name = DISPLAY_NAMES[id];
+  const thinkingLevelMap = THINKING_LEVEL_MAPS[id];
+  return {
+    id,
+    name: runtime.contextWindow > TWO_HUNDRED_K_CONTEXT && !/\b1M\b/i.test(name) ? `${name} 1M` : name,
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { ...ZERO_COST },
+    contextWindow: runtime.contextWindow,
+    maxTokens: 32_000,
+    ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
+  };
+}
+
+export const CLAUDE_BRIDGE_MODELS: ProviderModelConfig[] = MODEL_IDS_IN_ORDER.map(staticModel);
+
+export function registeredClaudeBridgeModels(
+  settings: LongContextSettings = DEFAULT_LONG_CONTEXT,
+): Model[] {
+  return applyLongContext(CLAUDE_BRIDGE_MODELS, settings).map((model) => ({
+    ...model,
+    api: CLAUDE_BRIDGE_API,
+    provider: PROVIDER_ID,
+    baseUrl: PROVIDER_ID,
+  }));
+}

package/plugins/kxm/src/providers/claude-bridge/pi-compat.ts

@@ -0,0 +1,215 @@
+/**
+ * Structural Pi stream types used by the vendored claude-bridge provider.
+ * No @earendil-works/pi-ai import (nested copy is forbidden).
+ */
+
+export type Api = string;
+export type ProviderId = string;
+export type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ModelThinkingLevel = "off" | ThinkingLevel;
+export type ThinkingLevelMap = Partial<Record<ModelThinkingLevel, string | null>>;
+
+export type ModelCostRates = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+};
+
+export type ModelCost = ModelCostRates;
+
+export type ProviderModelConfig = {
+  id: string;
+  name: string;
+  api?: Api;
+  baseUrl?: string;
+  reasoning: boolean;
+  thinkingLevelMap?: ThinkingLevelMap;
+  input: Array<"text" | "image">;
+  cost: ModelCost;
+  contextWindow: number;
+  maxTokens: number;
+};
+
+export type Model<TApi extends Api = Api> = ProviderModelConfig & {
+  api: TApi;
+  provider: ProviderId;
+  baseUrl: string;
+};
+
+export type TextContent = {
+  type: "text";
+  text: string;
+  textSignature?: string;
+};
+
+export type ThinkingContent = {
+  type: "thinking";
+  thinking: string;
+  thinkingSignature?: string;
+  redacted?: boolean;
+};
+
+export type ImageContent = {
+  type: "image";
+  data: string;
+  mimeType: string;
+};
+
+export type ToolCall = {
+  type: "toolCall";
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+  thoughtSignature?: string;
+};
+
+export type Usage = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  reasoning?: number;
+  totalTokens: number;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+};
+
+export type StopReason = "pending" | "stop" | "length" | "toolUse" | "error" | "aborted" | "deferred";
+
+export type UserMessage = {
+  role: "user";
+  content: string | Array<TextContent | ImageContent>;
+  timestamp: number;
+};
+
+export type AssistantMessage = {
+  role: "assistant";
+  content: Array<TextContent | ThinkingContent | ToolCall>;
+  api: Api;
+  provider: ProviderId;
+  model: string;
+  usage: Usage;
+  stopReason: StopReason;
+  errorMessage?: string;
+  timestamp: number;
+};
+
+export type ToolResultMessage = {
+  role: "toolResult";
+  toolCallId: string;
+  toolName?: string;
+  content: string | Array<TextContent | ImageContent>;
+  isError?: boolean;
+  timestamp?: number;
+};
+
+export type Message = UserMessage | AssistantMessage | ToolResultMessage;
+
+export type Tool = {
+  name: string;
+  description: string;
+  parameters: unknown;
+};
+
+export type Context = {
+  systemPrompt?: string;
+  messages: Message[];
+  tools?: Tool[];
+};
+
+export type AssistantMessageEvent =
+  | { type: "start"; partial: AssistantMessage }
+  | { type: "text_start"; contentIndex: number; partial: AssistantMessage }
+  | { type: "text_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
+  | { type: "text_end"; contentIndex: number; content: string; partial: AssistantMessage }
+  | { type: "thinking_start"; contentIndex: number; partial: AssistantMessage }
+  | { type: "thinking_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
+  | { type: "thinking_end"; contentIndex: number; content: string; partial: AssistantMessage }
+  | { type: "toolcall_start"; contentIndex: number; partial: AssistantMessage }
+  | { type: "toolcall_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
+  | { type: "toolcall_end"; contentIndex: number; toolCall: ToolCall; partial: AssistantMessage }
+  | { type: "done"; reason: StopReason; message: AssistantMessage }
+  | { type: "error"; reason: StopReason; error: AssistantMessage };
+
+export class AssistantMessageEventStream {
+  queue: AssistantMessageEvent[] = [];
+  waiting: Array<(result: { value?: AssistantMessageEvent; done: boolean }) => void> = [];
+  done = false;
+  finalResultPromise: Promise<AssistantMessage>;
+  private resolveFinalResult!: (message: AssistantMessage) => void;
+
+  constructor() {
+    this.finalResultPromise = new Promise((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+
+  push(event: AssistantMessageEvent): void {
+    if (this.done) return;
+    if (event.type === "done") {
+      this.done = true;
+      this.resolveFinalResult(event.message);
+    } else if (event.type === "error") {
+      this.done = true;
+      this.resolveFinalResult(event.error);
+    }
+    const waiter = this.waiting.shift();
+    if (waiter) waiter({ value: event, done: false });
+    else this.queue.push(event);
+  }
+
+  end(result?: AssistantMessage): void {
+    this.done = true;
+    if (result !== undefined) this.resolveFinalResult(result);
+    while (this.waiting.length > 0) {
+      this.waiting.shift()?.({ done: true });
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<AssistantMessageEvent> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!;
+      } else if (this.done) {
+        return;
+      } else {
+        const next = await new Promise<{ value?: AssistantMessageEvent; done: boolean }>((resolve) => {
+          this.waiting.push(resolve);
+        });
+        if (next.done) return;
+        if (next.value) yield next.value;
+      }
+    }
+  }
+
+  result(): Promise<AssistantMessage> {
+    return this.finalResultPromise;
+  }
+}
+
+export function createAssistantMessageEventStream(): AssistantMessageEventStream {
+  return new AssistantMessageEventStream();
+}
+
+export function emptyUsage(): Usage {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+}
+
+export type SimpleStreamOptions = {
+  signal?: AbortSignal;
+  cwd?: string;
+  reasoning?: ThinkingLevel;
+};

package/plugins/kxm/src/providers/claude-bridge/prompt-stream.ts

@@ -0,0 +1,89 @@
+// Long-lived streaming-input prompt for query().
+// Vendored from pi-claude-bridge 0.7.0 (provider path only).
+
+export type PromptUserMessage = {
+  type: "user";
+  message: { role: "user"; content: unknown };
+  parent_tool_use_id: null;
+  priority?: string;
+};
+
+export interface PromptStream {
+  stream: AsyncGenerator<PromptUserMessage>;
+  push: (msg: PromptUserMessage) => Promise<void>;
+  end: () => void;
+  fail: (error: Error) => void;
+}
+
+export function makePromptStream(): PromptStream {
+  type Item = { msg: PromptUserMessage; resolve: () => void; reject: (e: Error) => void };
+  const queue: Item[] = [];
+  let inflight: Item | null = null;
+  let wake: (() => void) | null = null;
+  let done = false;
+  let failure: Error | null = null;
+
+  const kick = () => {
+    wake?.();
+    wake = null;
+  };
+
+  async function* gen(): AsyncGenerator<PromptUserMessage> {
+    try {
+      while (true) {
+        while (queue.length === 0 && !done && !failure) {
+          await new Promise<void>((resolve) => {
+            wake = resolve;
+          });
+        }
+        if (failure) throw failure;
+        const item = queue.shift();
+        if (!item) return;
+        inflight = item;
+        try {
+          yield item.msg;
+          item.resolve();
+        } finally {
+          item.reject(new Error("prompt stream closed"));
+          inflight = null;
+        }
+      }
+    } finally {
+      done = true;
+    }
+  }
+
+  return {
+    stream: gen(),
+    push: (msg) =>
+      failure || done
+        ? Promise.reject(failure ?? new Error("prompt stream closed"))
+        : new Promise<void>((resolve, reject) => {
+            queue.push({ msg, resolve, reject });
+            kick();
+          }),
+    end: () => {
+      done = true;
+      kick();
+    },
+    fail: (error) => {
+      if (failure) return;
+      failure = error;
+      queue.splice(0).forEach((item) => item.reject(error));
+      inflight?.reject(error);
+      kick();
+    },
+  };
+}
+
+export function userMessage(
+  content: unknown,
+  priority?: string,
+): PromptUserMessage {
+  return {
+    type: "user",
+    message: { role: "user", content },
+    parent_tool_use_id: null,
+    ...(priority ? { priority } : {}),
+  };
+}