@kontextmind/kxm 0.7.16 → 0.7.18

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 } : {}),
+  };
+}

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

@@ -0,0 +1,286 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+import { createRequire } from "node:module";
+import type { Context, Model, SimpleStreamOptions } from "./pi-compat.ts";
+import { createAssistantMessageEventStream, type AssistantMessageEventStream } from "./pi-compat.ts";
+import {
+  claudeCodeModelId,
+  DEFAULT_LONG_CONTEXT,
+  resolveEffort,
+  type LongContextSettings,
+} from "./models.ts";
+import { claudeCodeSettings, loadConfig, longContextFromConfig, type ClaudeBridgeConfig } from "./config.ts";
+import { extractUserPrompt, extractUserPromptBlocks } from "./convert.ts";
+import { createToolServer } from "./mcp-server.ts";
+import { makePromptStream, userMessage } from "./prompt-stream.ts";
+import { QueryContext, ctx } from "./query-state.ts";
+import {
+  claimCurrentPiStream,
+  consumeQuery,
+  finalizeCurrentStream,
+  markStreamComplete,
+} from "./stream.ts";
+import {
+  extractAllToolResults,
+  MCP_SERVER_NAME,
+  resolveMcpTools,
+  type McpResult,
+} from "./tools.ts";
+
+export const CC_CHILD_ENV = {
+  ENABLE_CLAUDEAI_MCP_SERVERS: "0",
+  DISABLE_AUTO_COMPACT: "1",
+} as const;
+
+export const CLAUDE_MD_EXCLUDES = ["**/CLAUDE.md", "**/.claude/rules/**"];
+
+const require = createRequire(import.meta.url);
+const activeQueryContexts = new Set<QueryContext>();
+
+export type QueryHandle = AsyncIterable<unknown> & {
+  interrupt?: () => Promise<unknown> | unknown;
+  close?: () => void;
+};
+
+export type QueryFactory = (args: { prompt: unknown; options: Record<string, unknown> }) => QueryHandle;
+
+export type StreamDeps = {
+  query?: QueryFactory;
+  config?: ClaudeBridgeConfig;
+  longContext?: LongContextSettings;
+  nowCwd?: () => string;
+};
+
+let lastSessionId: string | undefined;
+
+export function resetClaudeBridgeSession(): void {
+  lastSessionId = undefined;
+  activeQueryContexts.clear();
+}
+
+export function getClaudeBridgeSessionId(): string | undefined {
+  return lastSessionId;
+}
+
+function buildMcpServers(tools: Context["tools"], queryCtx: QueryContext) {
+  if (!tools?.length) return undefined;
+  const mcpTools = tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.parameters,
+    handler: async (toolCallId: string) => {
+      if (queryCtx.pendingResults.has(toolCallId)) {
+        const result = queryCtx.pendingResults.get(toolCallId)!;
+        queryCtx.pendingResults.delete(toolCallId);
+        return result;
+      }
+      return new Promise<McpResult>((resolve) => {
+        queryCtx.pendingToolCalls.set(toolCallId, { toolName: tool.name, resolve });
+      });
+    },
+  }));
+  return { [MCP_SERVER_NAME]: createToolServer(MCP_SERVER_NAME, mcpTools) };
+}
+
+export function deliverToolResults(c: QueryContext, results: McpResult[]): void {
+  for (const result of results) {
+    const id = result.toolCallId;
+    if (id && c.pendingToolCalls.has(id)) {
+      const pending = c.pendingToolCalls.get(id)!;
+      c.pendingToolCalls.delete(id);
+      pending.resolve(result);
+    } else if (id) {
+      c.pendingResults.set(id, result);
+    }
+  }
+}
+
+function contextForToolResults(results: McpResult[]): QueryContext | undefined {
+  for (const result of results) {
+    const id = result.toolCallId;
+    if (!id) continue;
+    for (const queryCtx of activeQueryContexts) {
+      if (
+        queryCtx.pendingToolCalls.has(id) ||
+        queryCtx.pendingResults.has(id) ||
+        queryCtx.turnToolCallIds.includes(id)
+      ) {
+        return queryCtx;
+      }
+    }
+  }
+  return undefined;
+}
+
+let cachedQuery: QueryFactory | undefined;
+
+function loadAgentSdkQuery(): QueryFactory {
+  if (cachedQuery) return cachedQuery;
+  const mod = require("@anthropic-ai/claude-agent-sdk") as { query: QueryFactory };
+  cachedQuery = (args) => mod.query(args);
+  return cachedQuery;
+}
+
+export function setAgentSdkQueryForTests(factory: QueryFactory | undefined): void {
+  cachedQuery = factory;
+}
+
+export function streamClaudeBridge(
+  model: Model,
+  context: Context,
+  options?: SimpleStreamOptions,
+  deps: StreamDeps = {},
+): AssistantMessageEventStream {
+  const stream = createAssistantMessageEventStream();
+  const lastMsg = context.messages[context.messages.length - 1];
+  const allResults = activeQueryContexts.size > 0 ? extractAllToolResults(context.messages).results : [];
+  const resultCtx = allResults.length > 0 ? contextForToolResults(allResults) : undefined;
+
+  if (resultCtx) {
+    claimCurrentPiStream(stream, "tool-result", resultCtx);
+    resultCtx.resetTurnState(model);
+    deliverToolResults(resultCtx, allResults);
+    resultCtx.latestCursor = Math.max(resultCtx.latestCursor, context.messages.length);
+    return stream;
+  }
+
+  if (lastMsg?.role === "toolResult") {
+    const c = new QueryContext();
+    c.resetTurnState(model);
+    queueMicrotask(() => {
+      stream.push({ type: "done", reason: "stop", message: c.turnOutput });
+      markStreamComplete(stream);
+      stream.end();
+    });
+    return stream;
+  }
+
+  const queryCtx = ctx().activeQuery !== null ? new QueryContext() : ctx();
+  const { mcpTools, customToolNameToPi } = resolveMcpTools(context);
+  claimCurrentPiStream(stream, "fresh-query", queryCtx);
+  queryCtx.pendingToolCalls.clear();
+  queryCtx.pendingResults.clear();
+  queryCtx.turnToolCallIds = [];
+  queryCtx.resetTurnState(model);
+
+  const cwd = options?.cwd ?? deps.nowCwd?.() ?? process.cwd();
+  const config = deps.config ?? loadConfig(cwd);
+  const longContext = deps.longContext ?? longContextFromConfig(config);
+  const cliModel = claudeCodeModelId(model, longContext);
+  const promptBlocks = extractUserPromptBlocks(context.messages);
+  let promptText = extractUserPrompt(context.messages) ?? "";
+  if (!promptText && !promptBlocks) promptText = "[continue]";
+
+  const promptStream = makePromptStream();
+  void promptStream.push(userMessage(promptBlocks ?? [{ type: "text", text: promptText }])).catch(() => {});
+  queryCtx.promptStream = promptStream;
+  const mcpServers = buildMcpServers(mcpTools, queryCtx);
+  const effort = resolveEffort(options?.reasoning, model.thinkingLevelMap);
+  const extraArgs: Record<string, string | null> = { model: cliModel };
+  if (config.provider?.strictMcpConfig !== false) extraArgs["strict-mcp-config"] = null;
+  if (effort) extraArgs["thinking-display"] = "summarized";
+
+  const queryOptions: Record<string, unknown> = {
+    cwd,
+    env: { ...process.env, ...CC_CHILD_ENV },
+    tools: [],
+    permissionMode: "bypassPermissions",
+    includePartialMessages: true,
+    settings: {
+      ...claudeCodeSettings(config.provider),
+      claudeMdExcludes: CLAUDE_MD_EXCLUDES,
+      includeGitInstructions: false,
+    },
+    systemPrompt: {
+      type: "preset",
+      preset: "claude_code",
+      append: context.systemPrompt,
+    },
+    extraArgs,
+    ...(effort ? { effort } : {}),
+    ...(mcpServers ? { mcpServers } : {}),
+    ...(lastSessionId ? { resume: lastSessionId } : {}),
+    ...(config.provider?.pathToClaudeCodeExecutable
+      ? { pathToClaudeCodeExecutable: config.provider.pathToClaudeCodeExecutable }
+      : {}),
+  };
+
+  const queryFn = deps.query ?? loadAgentSdkQuery();
+  let wasAborted = false;
+  const sdkQuery = queryFn({ prompt: promptStream.stream, options: queryOptions });
+  queryCtx.activeQuery = sdkQuery;
+  activeQueryContexts.add(queryCtx);
+
+  const onAbort = () => {
+    wasAborted = true;
+    promptStream.fail(new Error("Operation aborted"));
+    queryCtx.releasePendingToolCalls("Operation aborted");
+    void sdkQuery.interrupt?.();
+    try {
+      sdkQuery.close?.();
+    } catch {
+      /* ignore */
+    }
+  };
+  if (options?.signal) {
+    if (options.signal.aborted) onAbort();
+    else options.signal.addEventListener("abort", onAbort, { once: true });
+  }
+
+  consumeQuery(sdkQuery as AsyncIterable<any>, customToolNameToPi, model, () => wasAborted, queryCtx)
+    .then(({ capturedSessionId }) => {
+      if (wasAborted || options?.signal?.aborted) {
+        if (queryCtx.turnOutput) {
+          queryCtx.turnOutput.stopReason = "aborted";
+          queryCtx.turnOutput.errorMessage = "Operation aborted";
+        }
+        const current = queryCtx.currentPiStream;
+        current?.push({ type: "error", reason: "aborted", error: queryCtx.turnOutput });
+        markStreamComplete(current);
+        current?.end();
+        queryCtx.currentPiStream = null;
+        return;
+      }
+      if (capturedSessionId) lastSessionId = capturedSessionId;
+      if (queryCtx.activeQuery === sdkQuery) queryCtx.activeQuery = null;
+      finalizeCurrentStream(queryCtx, queryCtx.turnOutput?.stopReason);
+    })
+    .catch((error) => {
+      promptStream.fail(error instanceof Error ? error : new Error(String(error)));
+      if (queryCtx.turnOutput) {
+        queryCtx.turnOutput.stopReason = options?.signal?.aborted ? "aborted" : "error";
+        queryCtx.turnOutput.errorMessage ??= error instanceof Error ? error.message : String(error);
+      }
+      if (queryCtx.activeQuery === sdkQuery) {
+        queryCtx.releasePendingToolCalls("Query ended");
+        queryCtx.activeQuery = null;
+      }
+      const current = queryCtx.currentPiStream;
+      current?.push({
+        type: "error",
+        reason: queryCtx.turnOutput?.stopReason ?? "error",
+        error: queryCtx.turnOutput,
+      });
+      markStreamComplete(current);
+      current?.end();
+      queryCtx.currentPiStream = null;
+    })
+    .finally(() => {
+      options?.signal?.removeEventListener("abort", onAbort);
+      promptStream.fail(new Error("query ended"));
+      if (queryCtx.promptStream === promptStream) queryCtx.promptStream = null;
+      if (queryCtx.activeQuery === sdkQuery || queryCtx.activeQuery === null) {
+        queryCtx.releasePendingToolCalls("Query ended");
+        queryCtx.activeQuery = null;
+        activeQueryContexts.delete(queryCtx);
+      }
+      try {
+        sdkQuery.close?.();
+      } catch {
+        /* ignore */
+      }
+    });
+
+  return stream;
+}
+
+export { DEFAULT_LONG_CONTEXT };

package/plugins/kxm/src/providers/claude-bridge/query-state.ts

@@ -0,0 +1,72 @@
+// @ts-nocheck — vendored snapshot; host tsconfig is stricter than upstream.
+import {
+  emptyUsage,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Model,
+} from "./pi-compat.ts";
+import type { McpResult } from "./tools.ts";
+import type { PromptStream } from "./prompt-stream.ts";
+
+export interface PendingToolCall {
+  toolName: string;
+  resolve: (result: McpResult) => void;
+}
+
+export class QueryContext {
+  activeQuery: unknown | null = null;
+  currentPiStream: AssistantMessageEventStream | null = null;
+  latestCursor = 0;
+  pendingToolCalls = new Map<string, PendingToolCall>();
+  pendingResults = new Map<string, McpResult>();
+  turnToolCallIds: string[] = [];
+  promptStream: PromptStream | null = null;
+  rateLimitRejection: { rateLimitType?: string; resetsAt?: number } | null = null;
+  lastRateLimitWarnStep: number | null = null;
+  lastRateLimitWarnThreshold: number | undefined;
+  sessionId: string | undefined;
+
+  turnOutput: AssistantMessage | null = null;
+  turnStarted = false;
+  turnSawStreamEvent = false;
+  turnSawToolCall = false;
+
+  get turnBlocks(): Array<any> {
+    if (!this.turnOutput) throw new Error("turnBlocks accessed before resetTurnState");
+    return this.turnOutput.content;
+  }
+
+  releasePendingToolCalls(reason: string): void {
+    for (const pending of this.pendingToolCalls.values()) {
+      pending.resolve({ content: [{ type: "text", text: reason }] });
+    }
+    this.pendingToolCalls.clear();
+    this.pendingResults.clear();
+  }
+
+  resetTurnState(model: Model): void {
+    this.turnOutput = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: emptyUsage(),
+      stopReason: "stop",
+      timestamp: Date.now(),
+    };
+    this.turnStarted = false;
+    this.turnSawStreamEvent = false;
+    this.turnSawToolCall = false;
+  }
+}
+
+let _ctx = new QueryContext();
+
+export function ctx(): QueryContext {
+  return _ctx;
+}
+
+export function resetCtx(): void {
+  _ctx = new QueryContext();
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Anthropic session / Keychain material that must not reach logs or telemetry.
+ * Complements plugins/kxm/src/redact.ts.
+ */
+
+const PATTERNS: Array<{ re: RegExp; replacement: string }> = [
+  { re: /\bsk-ant-[A-Za-z0-9_-]{8,}\b/g, replacement: "[redacted]" },
+  { re: /\bANTHROPIC_(?:API_KEY|AUTH_TOKEN|SESSION_KEY)=\S+/gi, replacement: "ANTHROPIC_[redacted]" },
+  { re: /\bCLAUDE_(?:API_KEY|SESSION_KEY)=\S+/gi, replacement: "CLAUDE_[redacted]" },
+  {
+    re: /("?(?:sessionKey|session_key|claude_oauth_token|anthropicApiKey|sk-ant)"?\s*[:=]\s*")[^"]*(")/gi,
+    replacement: "$1[redacted]$2",
+  },
+];
+
+export function redactClaudeBridgeSecrets(text: string): string {
+  let result = text;
+  for (const { re, replacement } of PATTERNS) {
+    result = result.replace(re, replacement);
+  }
+  return result;
+}
+
+export function looksLikeClaudeBridgeSecret(value: string): boolean {
+  return redactClaudeBridgeSecrets(value) !== value;
+}

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

@@ -0,0 +1,124 @@
+/**
+ * Register the Claude Bridge provider on a Pi extension host.
+ * Provider id stays `claude-bridge` so `claude login` credentials carry over.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  CLAUDE_BRIDGE_API,
+  PROVIDER_ID,
+  PROVIDER_NAME,
+  registeredClaudeBridgeModels,
+} from "./models.ts";
+import { streamClaudeBridge } from "./provider.ts";
+
+export const CLAUDE_BRIDGE_DOUBLE_REGISTRATION_WARNING =
+  "kxm: standalone pi-claude-bridge is still installed (AskClaude tool is present). Remove that extension and reload. KXM will not register provider id claude-bridge.";
+
+export const CLAUDE_BRIDGE_ALREADY_REGISTERED_WARNING =
+  "kxm: standalone pi-claude-bridge is still installed (AskClaude tool is present). KXM already registered provider id claude-bridge. Remove that extension and reload to avoid override or ambiguity.";
+
+/** Tools that only the standalone extension registers. */
+export const STANDALONE_CLAUDE_BRIDGE_TOOLS = Object.freeze(["AskClaude"]);
+
+/** Real ExtensionAPI probes that can observe the standalone AskClaude tool. */
+export const CLAUDE_BRIDGE_HOST_PROBE_METHODS = Object.freeze([
+  "getAllTools",
+  "getActiveTools",
+  "getCommands",
+] as const);
+
+export type ClaudeBridgeRegistration = {
+  registered: boolean;
+  conflict: boolean;
+  warning?: string;
+};
+
+type HostProbe = Pick<ExtensionAPI, (typeof CLAUDE_BRIDGE_HOST_PROBE_METHODS)[number]>;
+
+function asProbe(pi: object): Partial<HostProbe> {
+  return pi as Partial<HostProbe>;
+}
+
+function collectHostSignalNames(pi: object): string[] {
+  const probe = asProbe(pi);
+  const names: string[] = [];
+  try {
+    for (const tool of probe.getAllTools?.() ?? []) {
+      if (typeof tool.name === "string") names.push(tool.name);
+    }
+  } catch {
+    /* getAllTools may throw before the runner is bound */
+  }
+  try {
+    for (const name of probe.getActiveTools?.() ?? []) {
+      if (typeof name === "string") names.push(name);
+    }
+  } catch {
+    /* getActiveTools may throw before the runner is bound */
+  }
+  try {
+    for (const command of probe.getCommands?.() ?? []) {
+      if (typeof command.name === "string") names.push(command.name);
+    }
+  } catch {
+    /* getCommands may throw before the session is ready */
+  }
+  return names;
+}
+
+export function claudeBridgeStandaloneToolsPresent(pi: object): boolean {
+  const names = collectHostSignalNames(pi);
+  return STANDALONE_CLAUDE_BRIDGE_TOOLS.some((name) => names.includes(name));
+}
+
+export function shouldSkipClaudeBridgeRegistration(pi: object): boolean {
+  return claudeBridgeStandaloneToolsPresent(pi);
+}
+
+function boundedRegistrationWarning(message: string): string {
+  return message.slice(0, 400);
+}
+
+export function claudeBridgeConflictWarning(registered: boolean): string {
+  return boundedRegistrationWarning(
+    registered
+      ? CLAUDE_BRIDGE_ALREADY_REGISTERED_WARNING
+      : CLAUDE_BRIDGE_DOUBLE_REGISTRATION_WARNING,
+  );
+}
+
+export function claudeBridgeRegistrationNotice(
+  report: ClaudeBridgeRegistration | undefined,
+  pi?: object,
+): { message: string; type: "warning" } | undefined {
+  const conflict = Boolean(report?.conflict) || (pi ? claudeBridgeStandaloneToolsPresent(pi) : false);
+  if (!conflict) return undefined;
+  return {
+    message: claudeBridgeConflictWarning(Boolean(report?.registered)),
+    type: "warning",
+  };
+}
+
+export function registerClaudeBridgeProvider(pi: ExtensionAPI): ClaudeBridgeRegistration {
+  if (shouldSkipClaudeBridgeRegistration(pi)) {
+    return {
+      registered: false,
+      conflict: true,
+      warning: CLAUDE_BRIDGE_DOUBLE_REGISTRATION_WARNING,
+    };
+  }
+  if (typeof pi.registerProvider !== "function") {
+    return { registered: false, conflict: false };
+  }
+
+  pi.registerProvider(PROVIDER_ID, {
+    name: PROVIDER_NAME,
+    baseUrl: PROVIDER_ID,
+    api: CLAUDE_BRIDGE_API,
+    models: registeredClaudeBridgeModels(),
+    streamSimple: streamClaudeBridge,
+  } as unknown as Parameters<ExtensionAPI["registerProvider"]>[1]);
+
+  return { registered: true, conflict: false };
+}