@kontextmind/kxm 0.7.15 → 0.7.16

package/plugins/kxm/src/providers/antigravity/pi-compat.ts

@@ -0,0 +1,279 @@
+/**
+ * Structural Pi stream/auth types used by the vendored Antigravity 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 ToolChoiceSimple = "auto" | "none";
+
+export type ModelCostRates = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+};
+
+export type ModelCost = ModelCostRates & {
+  tiers?: Array<ModelCostRates & { inputTokensAbove: number }>;
+};
+
+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;
+  headers?: Record<string, string>;
+};
+
+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;
+  cacheWrite1h?: 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;
+  rawStopReason?: string;
+  timestamp: number;
+};
+
+export type ToolResultMessage = {
+  role: "toolResult";
+  toolCallId: string;
+  toolName: string;
+  content: 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 calculateCost(model: { cost?: ModelCost }, usage: Usage): Usage["cost"] {
+  const rates = model.cost;
+  if (!rates) {
+    usage.cost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    return usage.cost;
+  }
+  const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+  let applied: ModelCostRates = rates;
+  let matchedThreshold = -1;
+  for (const tier of rates.tiers ?? []) {
+    if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+      applied = tier;
+      matchedThreshold = tier.inputTokensAbove;
+    }
+  }
+  const longWrite = usage.cacheWrite1h ?? 0;
+  const shortWrite = usage.cacheWrite - longWrite;
+  usage.cost.input = (applied.input / 1_000_000) * usage.input;
+  usage.cost.output = (applied.output / 1_000_000) * usage.output;
+  usage.cost.cacheRead = (applied.cacheRead / 1_000_000) * usage.cacheRead;
+  usage.cost.cacheWrite = (applied.cacheWrite * shortWrite + applied.input * 2 * longWrite) / 1_000_000;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+  return usage.cost;
+}
+
+export type OAuthCredentials = {
+  refresh: string;
+  access: string;
+  expires: number;
+  [key: string]: unknown;
+};
+
+export type OAuthLoginCallbacks = {
+  onAuth(info: { url: string; instructions?: string }): void;
+  onDeviceCode?(info: { userCode: string; verificationUri: string }): void;
+  onPrompt?(prompt: { message: string; placeholder?: string }): Promise<string>;
+  onProgress?(message: string): void;
+  onSelect?(prompt: { message: string; options: Array<{ id: string; label: string }> }): Promise<string | undefined>;
+  signal?: AbortSignal;
+};
+
+export type ApiKeyCredential = {
+  type: "api_key";
+  key?: string;
+};
+
+export type OAuthCredential = OAuthCredentials & {
+  type: "oauth";
+};
+
+export type Credential = ApiKeyCredential | OAuthCredential;
+
+export type ModelsStoreEntry = Record<string, unknown>;
+
+export type RefreshModelsContext = {
+  credential?: Credential;
+  stored?: Readonly<ModelsStoreEntry>;
+  publish(publication: { persist?: ModelsStoreEntry | null }): Promise<boolean>;
+  allowNetwork: boolean;
+  force?: boolean;
+  signal: AbortSignal;
+};
+
+export type SimpleStreamOptions = {
+  signal?: AbortSignal;
+  apiKey?: string;
+  temperature?: number;
+  maxTokens?: number;
+  sessionId?: string;
+  reasoning?: ThinkingLevel;
+  toolChoice?: ToolChoiceSimple | string;
+  onPayload?: (payload: unknown, model: Model<Api>) => unknown | undefined | Promise<unknown | undefined>;
+  onResponse?: (response: { status: number; headers: Record<string, string> }, model: Model<Api>) => void | Promise<void>;
+};

package/plugins/kxm/src/providers/antigravity/register.ts

@@ -0,0 +1,123 @@
+/**
+ * Register the Antigravity provider on a Pi extension host.
+ * Provider id stays `antigravity` so existing auth-store logins carry over.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getApiKey, loginAntigravity, refreshAntigravityToken } from "./auth/index.ts";
+import { DEFAULT_ENDPOINT, endpointCandidates } from "./client/index.ts";
+import {
+  getCurrentAntigravityCatalog,
+  PROVIDER_ID,
+  PROVIDER_NAME,
+  refreshAntigravityModels,
+} from "./models/index.ts";
+import { ANTIGRAVITY_API, streamAntigravity } from "./stream/index.ts";
+import { prewarmConnection } from "./utils/index.ts";
+
+export const ANTIGRAVITY_DOUBLE_REGISTRATION_WARNING =
+  "kxm: standalone pi-antigravity is still installed. Remove that extension and reload. KXM will not double-register provider id antigravity.";
+
+/** Slash commands that only the standalone extension registers. */
+export const STANDALONE_ANTIGRAVITY_COMMANDS = Object.freeze([
+  "antigravity.image",
+  "antigravity.models",
+  "antigravity.doctor",
+  "antigravity.usage",
+  "antigravity.refresh",
+]);
+
+export type AntigravityRegistration = {
+  registered: boolean;
+  conflict: boolean;
+  warning?: string;
+};
+
+type ProviderProbe = {
+  getRegisteredProviderIds?: () => readonly string[];
+  getCommands?: () => ReadonlyArray<{ name?: string }>;
+  modelRegistry?: {
+    getRegisteredProviderIds?: () => readonly string[];
+    getProvider?: (id: string) => unknown;
+  };
+};
+
+function asProbe(pi: object): ProviderProbe {
+  return pi as ProviderProbe;
+}
+
+function registeredProviderIds(probe: ProviderProbe): string[] {
+  return [
+    ...(probe.getRegisteredProviderIds?.() ?? []),
+    ...(probe.modelRegistry?.getRegisteredProviderIds?.() ?? []),
+  ];
+}
+
+export function antigravityStandaloneCommandsPresent(pi: object): boolean {
+  const probe = asProbe(pi);
+  let names: string[] = [];
+  try {
+    names = (probe.getCommands?.() ?? [])
+      .map((command) => command.name)
+      .filter((name): name is string => typeof name === "string");
+  } catch {
+    return false;
+  }
+  return STANDALONE_ANTIGRAVITY_COMMANDS.some((name) => names.includes(name));
+}
+
+export function antigravityProviderRegistered(pi: object): boolean {
+  const probe = asProbe(pi);
+  const ids = registeredProviderIds(probe);
+  if (ids.includes(PROVIDER_ID)) return true;
+  if (probe.modelRegistry?.getProvider?.(PROVIDER_ID)) return true;
+  return false;
+}
+
+export function shouldSkipAntigravityRegistration(pi: object): boolean {
+  return antigravityProviderRegistered(pi) || antigravityStandaloneCommandsPresent(pi);
+}
+
+export function antigravityRegistrationNotice(
+  report: AntigravityRegistration | undefined,
+  pi?: object,
+): { message: string; type: "warning" } | undefined {
+  const conflict = Boolean(report?.conflict) || (pi ? antigravityStandaloneCommandsPresent(pi) : false);
+  if (!conflict) return undefined;
+  const warning = (report?.warning ?? ANTIGRAVITY_DOUBLE_REGISTRATION_WARNING).slice(0, 400);
+  return { message: warning, type: "warning" };
+}
+
+export function registerAntigravityProvider(pi: ExtensionAPI): AntigravityRegistration {
+  if (shouldSkipAntigravityRegistration(pi)) {
+    return {
+      registered: false,
+      conflict: true,
+      warning: ANTIGRAVITY_DOUBLE_REGISTRATION_WARNING,
+    };
+  }
+  if (typeof pi.registerProvider !== "function") {
+    return { registered: false, conflict: false };
+  }
+
+  const primaryEndpoint = endpointCandidates()[0];
+  if (primaryEndpoint) prewarmConnection(primaryEndpoint);
+
+  pi.registerProvider(PROVIDER_ID, {
+    name: PROVIDER_NAME,
+    baseUrl: DEFAULT_ENDPOINT,
+    api: ANTIGRAVITY_API,
+    models: getCurrentAntigravityCatalog().models,
+    refreshModels: refreshAntigravityModels,
+    oauth: {
+      name: PROVIDER_NAME,
+      isSubscription: true,
+      login: loginAntigravity,
+      refreshToken: refreshAntigravityToken,
+      getApiKey,
+    },
+    streamSimple: streamAntigravity,
+  } as unknown as Parameters<ExtensionAPI["registerProvider"]>[1]);
+
+  return { registered: true, conflict: false };
+}

package/plugins/kxm/src/providers/antigravity/stream/index.ts

@@ -0,0 +1 @@
+export * from "./stream.ts";