@seqyuan/annodex 0.1.11 → 0.1.12

package/lib/codex-usage.ts

@@ -0,0 +1,213 @@
+import { existsSync, readFileSync } from "fs";
+import type { AssistantMessage } from "./types";
+import { getKnownModelDefaults, listAllModels, readMergedConfig } from "./annodex-config";
+
+interface UsageNumbers {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cachedTokens: number;
+}
+
+interface UsageSnapshot {
+  turnId: string | null;
+  observedAt: string;
+  last: UsageNumbers;
+  total: UsageNumbers;
+  contextWindow: number;
+}
+
+export interface CodexSessionUsage {
+  messageUsageByTurnId: Map<string, AssistantMessage["usage"]>;
+  sessionStats: {
+    tokens: { input: number; output: number; cacheRead: number; cacheWrite: number };
+    cost: number;
+  } | null;
+  contextUsage: { percent: number | null; contextWindow: number; tokens: number | null } | null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function numberValue(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function parseUsageNumbers(value: unknown): UsageNumbers {
+  if (!isRecord(value)) {
+    return { inputTokens: 0, outputTokens: 0, totalTokens: 0, cachedTokens: 0 };
+  }
+  const inputTokens = numberValue(value.input_tokens ?? value.prompt_tokens ?? value.promptTokenCount);
+  const outputTokens = numberValue(value.output_tokens ?? value.completion_tokens ?? value.candidatesTokenCount);
+  const cachedTokens = numberValue(
+    value.cached_input_tokens
+      ?? value.cache_read_input_tokens
+      ?? value.prompt_cache_hit_tokens
+      ?? (isRecord(value.input_tokens_details) ? value.input_tokens_details.cached_tokens : undefined)
+      ?? (isRecord(value.prompt_tokens_details) ? value.prompt_tokens_details.cached_tokens : undefined)
+      ?? value.cachedContentTokenCount,
+  );
+  const totalTokens = numberValue(value.total_tokens ?? value.totalTokens) || inputTokens + outputTokens;
+  return { inputTokens, outputTokens, totalTokens, cachedTokens };
+}
+
+function hasUsage(usage: UsageNumbers): boolean {
+  return usage.inputTokens > 0 || usage.outputTokens > 0 || usage.totalTokens > 0 || usage.cachedTokens > 0;
+}
+
+function usageKey(snapshot: UsageSnapshot): string {
+  return [
+    snapshot.turnId ?? "",
+    snapshot.last.inputTokens,
+    snapshot.last.outputTokens,
+    snapshot.last.totalTokens,
+    snapshot.last.cachedTokens,
+    snapshot.total.inputTokens,
+    snapshot.total.outputTokens,
+    snapshot.total.totalTokens,
+    snapshot.total.cachedTokens,
+    snapshot.contextWindow,
+  ].join("|");
+}
+
+function parseJsonLine(line: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(line) as unknown;
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function payloadRecord(line: Record<string, unknown>): Record<string, unknown> | null {
+  return isRecord(line.payload) ? line.payload : null;
+}
+
+function contextWindowForModel(modelId?: string | null): number {
+  if (!modelId) return 0;
+  const known = getKnownModelDefaults(modelId);
+  if (known?.contextWindow) return known.contextWindow;
+  try {
+    const match = listAllModels(readMergedConfig()).find((model) => model.modelId === modelId);
+    return match?.contextWindow ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+function assistantUsageFromSnapshot(snapshot: UsageSnapshot): AssistantMessage["usage"] {
+  const input = snapshot.last.inputTokens;
+  const output = snapshot.last.outputTokens;
+  const cacheRead = snapshot.last.cachedTokens;
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite: 0,
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      total: 0,
+    },
+  };
+}
+
+export function readCodexUsageFromFile(filePath: string | null, fallbackModelId?: string | null): CodexSessionUsage {
+  if (!filePath || !existsSync(filePath)) {
+    return { messageUsageByTurnId: new Map(), sessionStats: null, contextUsage: null };
+  }
+
+  let content = "";
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return { messageUsageByTurnId: new Map(), sessionStats: null, contextUsage: null };
+  }
+
+  const snapshots: UsageSnapshot[] = [];
+  let currentTurnId: string | null = null;
+  let currentModelId = fallbackModelId ?? null;
+  let lastKey = "";
+
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    const item = parseJsonLine(line);
+    if (!item) continue;
+    const payload = payloadRecord(item) ?? item;
+
+    if (item.type === "turn_context") {
+      currentTurnId = typeof payload.turn_id === "string" ? payload.turn_id : null;
+      if (typeof payload.model === "string" && payload.model.trim()) currentModelId = payload.model;
+      continue;
+    }
+
+    if (item.type !== "event_msg" || payload.type !== "token_count" || !isRecord(payload.info)) {
+      continue;
+    }
+
+    const last = parseUsageNumbers(payload.info.last_token_usage);
+    const total = parseUsageNumbers(payload.info.total_token_usage);
+    const contextWindow = numberValue(payload.info.model_context_window) || contextWindowForModel(currentModelId);
+    const contextTokens = total.totalTokens || last.totalTokens;
+    if (!hasUsage(last) && !hasUsage(total) && contextTokens <= 0) continue;
+
+    const snapshot: UsageSnapshot = {
+      turnId: currentTurnId,
+      observedAt: typeof item.timestamp === "string" ? item.timestamp : "",
+      last,
+      total,
+      contextWindow,
+    };
+    const key = usageKey(snapshot);
+    if (key === lastKey) continue;
+    lastKey = key;
+    snapshots.push(snapshot);
+  }
+
+  const byTurn = new Map<string, UsageSnapshot>();
+  for (const snapshot of snapshots) {
+    if (snapshot.turnId) byTurn.set(snapshot.turnId, snapshot);
+  }
+
+  const messageUsageByTurnId = new Map<string, AssistantMessage["usage"]>();
+  for (const [turnId, snapshot] of byTurn) {
+    messageUsageByTurnId.set(turnId, assistantUsageFromSnapshot(snapshot));
+  }
+
+  const latest = snapshots[snapshots.length - 1];
+  const total = latest?.total;
+  const totalInput = total?.inputTokens ?? 0;
+  const totalOutput = total?.outputTokens ?? 0;
+  const totalCacheRead = total?.cachedTokens ?? 0;
+  const sessionTotal = totalInput + totalOutput + totalCacheRead;
+  const sessionStats = sessionTotal > 0
+    ? {
+        tokens: {
+          input: totalInput,
+          output: totalOutput,
+          cacheRead: totalCacheRead,
+          cacheWrite: 0,
+        },
+        cost: 0,
+      }
+    : null;
+
+  const contextWindow = latest?.contextWindow ?? contextWindowForModel(currentModelId);
+  const contextTokens = latest ? (latest.last.totalTokens || latest.last.inputTokens || null) : null;
+  const contextUsage = contextWindow > 0
+    ? {
+        percent: contextTokens !== null ? Math.min(100, (contextTokens / contextWindow) * 100) : null,
+        contextWindow,
+        tokens: contextTokens,
+      }
+    : null;
+
+  return { messageUsageByTurnId, sessionStats, contextUsage };
+}
+
+export const __codexUsageTest = {
+  readCodexUsageFromFile,
+};

package/lib/file-paths.ts

@@ -0,0 +1,34 @@
+export function normalizeFilePathSlashes(filePath: string): string {
+  if (/^[a-zA-Z]:[\\/]/.test(filePath) || filePath.startsWith("\\\\")) {
+    return filePath.replace(/\\/g, "/");
+  }
+  return filePath;
+}
+
+export function encodeFilePathForApi(filePath: string): string {
+  return normalizeFilePathSlashes(filePath)
+    .split("/")
+    .filter(Boolean)
+    .map(encodeURIComponent)
+    .join("/");
+}
+
+export function getFileName(filePath: string): string {
+  const normalized = normalizeFilePathSlashes(filePath).replace(/\/+$/, "");
+  return normalized.split("/").pop() ?? normalized;
+}
+
+export function getRelativeFilePath(filePath: string, cwd?: string): string {
+  if (!cwd) return filePath;
+
+  const normalizedFile = normalizeFilePathSlashes(filePath);
+  const normalizedCwd = normalizeFilePathSlashes(cwd).replace(/\/$/, "");
+  if (normalizedFile.startsWith(normalizedCwd + "/")) {
+    return normalizedFile.slice(normalizedCwd.length + 1);
+  }
+  return filePath;
+}
+
+export function joinFilePath(parent: string, child: string): string {
+  return `${normalizeFilePathSlashes(parent).replace(/\/$/, "")}/${child}`;
+}

package/lib/model-discovery.ts

@@ -0,0 +1,379 @@
+import { inferModelApi, inferProviderApi, type ProviderApi } from "./provider-api";
+
+export interface DiscoveredModel {
+  id: string;
+  name: string;
+  ownedBy: string;
+  input?: string[];
+  contextWindow?: number;
+  maxTokens?: number;
+}
+
+export interface PiModelImport {
+  id: string;
+  name: string;
+  api?: ProviderApi;
+  input?: string[];
+  contextWindow: number;
+  maxTokens: number;
+  reasoning?: boolean;
+}
+
+const DEFAULT_CONFIGS = {
+  claude: { contextWindow: 200000, maxTokens: 16000 },
+  gpt: { contextWindow: 200000, maxTokens: 16000 },
+  deepseek: { contextWindow: 128000, maxTokens: 8192 },
+  qwen: { contextWindow: 128000, maxTokens: 8192 },
+  llama: { contextWindow: 8192, maxTokens: 4096 },
+  default: { contextWindow: 200000, maxTokens: 16000 },
+};
+
+const CONTEXT_WINDOW_KEYS = [
+  "contextWindow",
+  "context_window",
+  "context_length",
+  "contextLength",
+  "max_context_length",
+  "maxContextLength",
+  "max_model_len",
+  "model_max_length",
+  "input_token_limit",
+  "max_input_tokens",
+  "maxInputTokens",
+  "num_ctx",
+  "n_ctx",
+];
+
+const MAX_TOKENS_KEYS = [
+  "maxTokens",
+  "max_tokens",
+  "max_output_tokens",
+  "maxOutputTokens",
+  "max_completion_tokens",
+  "maxCompletionTokens",
+  "output_token_limit",
+  "completion_token_limit",
+];
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function unique(items: string[]): string[] {
+  return Array.from(new Set(items));
+}
+
+export function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.trim().replace(/\/+$/, "");
+}
+
+export function getModelListEndpoints(baseUrl: string): string[] {
+  const normalized = normalizeBaseUrl(baseUrl);
+  return unique([
+    `${normalized}/v1/models`,
+    `${normalized}/models`,
+    `${normalized}/api/models`,
+    `${normalized}/api/tags`,
+  ]);
+}
+
+function buildHeaders(apiKey: string): HeadersInit {
+  return apiKey.trim() ? { authorization: `Bearer ${apiKey.trim()}` } : {};
+}
+
+export async function fetchModelsFromBaseUrl(baseUrl: string, apiKey = ""): Promise<{ endpoint: string; models: DiscoveredModel[] }> {
+  const headers = buildHeaders(apiKey);
+  const errors: string[] = [];
+  const timeoutMs = 8000;
+
+  for (const endpoint of getModelListEndpoints(baseUrl)) {
+    try {
+      const response = await fetch(endpoint, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(timeoutMs),
+      });
+      if (response.status === 200) {
+        const payload = await response.json() as unknown;
+        return { endpoint, models: parseModelList(payload) };
+      }
+      if (response.status !== 404) {
+        errors.push(`${endpoint}: HTTP ${response.status}`);
+      }
+    } catch (error) {
+      errors.push(`${endpoint}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  throw new Error(errors.length ? errors.join("; ") : "Could not connect to any model endpoint");
+}
+
+export function parseModelList(payload: unknown): DiscoveredModel[] {
+  const modelsData = getModelsData(payload);
+  const models: DiscoveredModel[] = [];
+
+  for (const item of modelsData) {
+    if (typeof item === "string") {
+      models.push({ id: item, name: item, ownedBy: "unknown" });
+      continue;
+    }
+
+    if (!isRecord(item)) continue;
+
+    const id = getStringField(item, ["id", "model_id", "name", "model"]);
+    if (!id) continue;
+
+    const limits = extractModelLimits(item);
+    const input = extractInputTypes(item);
+    models.push({
+      id,
+      name: getStringField(item, ["name"]) ?? id,
+      ownedBy: getStringField(item, ["owned_by", "ownedBy"]) ?? "unknown",
+      ...(input ? { input } : {}),
+      ...limits,
+    });
+  }
+
+  return models;
+}
+
+export async function enrichModelsWithRemoteMetadata(baseUrl: string, apiKey: string, models: DiscoveredModel[]): Promise<DiscoveredModel[]> {
+  const enriched = models.map((model) => ({ ...model }));
+  const needDetail = enriched.filter((model) => model.contextWindow === undefined || model.maxTokens === undefined);
+  if (needDetail.length === 0) return enriched;
+
+  for (const model of needDetail) {
+    const detail = await fetchModelDetail(baseUrl, apiKey, model.id);
+    if (!detail) continue;
+    const limits = extractModelLimits(detail);
+    const input = extractInputTypes(detail);
+    model.contextWindow ??= limits.contextWindow;
+    model.maxTokens ??= limits.maxTokens;
+    model.input ??= input;
+  }
+
+  return enriched;
+}
+
+async function fetchModelDetail(baseUrl: string, apiKey: string, modelId: string): Promise<Record<string, unknown> | undefined> {
+  const headers = buildHeaders(apiKey);
+  const normalized = normalizeBaseUrl(baseUrl);
+  const encodedModelId = encodeURIComponent(modelId);
+  const getEndpoints = unique([
+    `${normalized}/v1/models/${encodedModelId}`,
+    `${normalized}/models/${encodedModelId}`,
+    `${normalized}/api/models/${encodedModelId}`,
+  ]);
+
+  for (const endpoint of getEndpoints) {
+    try {
+      const response = await fetch(endpoint, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(15000),
+      });
+      if (response.status === 200) {
+        const data = await response.json() as unknown;
+        if (isRecord(data)) return data;
+      }
+    } catch {
+      // Try the next detail endpoint.
+    }
+  }
+
+  try {
+    const response = await fetch(`${normalized}/api/show`, {
+      method: "POST",
+      headers: { ...headers, "content-type": "application/json" },
+      body: JSON.stringify({ name: modelId }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (response.status === 200) {
+      const data = await response.json() as unknown;
+      if (isRecord(data)) return data;
+    }
+  } catch {
+    // Ollama detail endpoint is optional.
+  }
+
+  return undefined;
+}
+
+export function convertToPiModels(models: DiscoveredModel[], includeProviderPrefix = false, provider?: string, baseUrl?: string): PiModelImport[] {
+  const providerApi = inferProviderApi(baseUrl, provider);
+  return models.map((model) => {
+    const fallback = estimateModelParams(model.id);
+    const input = inferModelInputTypes(model);
+    const api = inferModelApi(model.id, providerApi, baseUrl, provider);
+    return {
+      id: includeProviderPrefix && provider ? `${provider}/${model.id}` : model.id,
+      name: model.name ?? model.id,
+      ...(api && api !== providerApi ? { api } : {}),
+      ...(input ? { input } : {}),
+      contextWindow: model.contextWindow ?? fallback.contextWindow,
+      maxTokens: model.maxTokens ?? fallback.maxTokens,
+      ...(fallback.reasoning ? { reasoning: true } : {}),
+    };
+  });
+}
+
+function getModelsData(payload: unknown): unknown[] {
+  if (Array.isArray(payload)) return payload;
+  if (!isRecord(payload)) throw new Error("Could not parse model response format");
+  if (Array.isArray(payload.data)) return payload.data;
+  if (Array.isArray(payload.models)) return payload.models;
+  throw new Error("Could not parse model response format");
+}
+
+function extractModelLimits(modelData: unknown): { contextWindow?: number; maxTokens?: number } {
+  const contextWindow = findNumericField(modelData, CONTEXT_WINDOW_KEYS);
+  const maxTokens = findNumericField(modelData, MAX_TOKENS_KEYS);
+  return {
+    ...(contextWindow ? { contextWindow } : {}),
+    ...(maxTokens ? { maxTokens } : {}),
+  };
+}
+
+export function inferModelInputTypes(model: Pick<DiscoveredModel, "id" | "name" | "ownedBy" | "input">): string[] | undefined {
+  if (model.input?.includes("image")) return ["text", "image"];
+  if (looksLikeImageModel(model.id, model.name, model.ownedBy)) return ["text", "image"];
+  return undefined;
+}
+
+function estimateModelParams(modelId: string): { contextWindow: number; maxTokens: number; reasoning?: boolean } {
+  const lower = modelId.toLowerCase();
+
+  if (lower.includes("claude")) {
+    return {
+      ...DEFAULT_CONFIGS.claude,
+      ...((lower.includes("thinking") || lower.includes("reasoning")) ? { reasoning: true } : {}),
+    };
+  }
+  if (lower.includes("gpt")) return { ...DEFAULT_CONFIGS.gpt };
+  if (lower.includes("deepseek")) return { ...DEFAULT_CONFIGS.deepseek };
+  if (lower.includes("qwen")) return { ...DEFAULT_CONFIGS.qwen };
+  if (lower.includes("llama")) return { ...DEFAULT_CONFIGS.llama };
+
+  return { ...DEFAULT_CONFIGS.default };
+}
+
+function extractInputTypes(modelData: unknown): string[] | undefined {
+  if (!isRecord(modelData)) return undefined;
+  if (hasImageCapability(modelData)) return ["text", "image"];
+  return undefined;
+}
+
+function hasImageCapability(value: unknown): boolean {
+  if (typeof value === "string") return isImageCapabilityText(value);
+  if (typeof value === "boolean" || typeof value === "number" || value === null) return false;
+
+  if (Array.isArray(value)) {
+    return value.some((item) => hasImageCapability(item));
+  }
+
+  if (!isRecord(value)) return false;
+
+  for (const [key, entry] of Object.entries(value)) {
+    const normalizedKey = normalizeKey(key);
+    if (typeof entry === "boolean" && entry && IMAGE_CAPABILITY_KEYS.has(normalizedKey)) return true;
+    if (IMAGE_CAPABILITY_CONTAINER_KEYS.has(normalizedKey) && hasImageCapability(entry)) return true;
+  }
+
+  return false;
+}
+
+function isImageCapabilityText(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized === "image" || normalized === "images" || normalized === "vision" || normalized === "visual" || normalized === "multimodal";
+}
+
+const IMAGE_CAPABILITY_KEYS = new Set(["image", "images", "vision", "visual", "multimodal"]);
+const IMAGE_CAPABILITY_CONTAINER_KEYS = new Set([
+  "input",
+  "inputs",
+  "inputmodalities",
+  "modalities",
+  "modality",
+  "supportedmodalities",
+  "capabilities",
+  "features",
+  "architecture",
+  "details",
+  "family",
+]);
+
+function looksLikeImageModel(id: string, name?: string, ownedBy?: string): boolean {
+  const text = [id, name, ownedBy].filter(Boolean).join(" ").toLowerCase();
+  if (!text) return false;
+
+  const tokenized = text.replace(/[^a-z0-9]+/g, " ");
+  if (/\b(?:vision|visual|multimodal|image|images|llava|pixtral|internvl|minicpmv|glm4v)\b/.test(tokenized)) {
+    return true;
+  }
+  if (/(^|[^a-z0-9])(?:vl|v)(?:[^a-z0-9]|$)/.test(text)) return true;
+  if (/\bqwen[0-9.]*\s*vl\b|\bqwen\s*vl\b/.test(tokenized)) return true;
+  if (/\bgpt\s*4o\b|\bgpt\s*4\s*1\b|\bo3\b|\bo4\b/.test(tokenized)) return true;
+  if (/\bgemini\b|\bclaude\s*3\b|\bclaude\s*(?:sonnet|opus|haiku)\s*4\b/.test(tokenized)) return true;
+  return false;
+}
+
+function findNumericField(data: unknown, keys: string[]): number | undefined {
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      const found = findNumericField(item, keys);
+      if (found) return found;
+    }
+    return undefined;
+  }
+
+  if (!isRecord(data)) return undefined;
+
+  for (const expectedKey of keys) {
+    for (const [actualKey, value] of Object.entries(data)) {
+      if (keyMatches(actualKey, expectedKey)) {
+        const parsed = parseTokenLimit(value);
+        if (parsed) return parsed;
+      }
+    }
+  }
+
+  for (const value of Object.values(data)) {
+    const found = findNumericField(value, keys);
+    if (found) return found;
+  }
+
+  return undefined;
+}
+
+function parseTokenLimit(value: unknown): number | undefined {
+  if (typeof value === "boolean") return undefined;
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  if (typeof value !== "string") return undefined;
+
+  const text = value.trim().toLowerCase().replace(/[, _]/g, "");
+  const match = /^(\d+(?:\.\d+)?)([km])?$/.exec(text);
+  if (!match) return undefined;
+
+  let number = Number.parseFloat(match[1]);
+  if (match[2] === "k") number *= 1000;
+  if (match[2] === "m") number *= 1000000;
+  return number > 0 ? Math.trunc(number) : undefined;
+}
+
+function keyMatches(actualKey: string, expectedKey: string): boolean {
+  const actual = normalizeKey(actualKey);
+  const expected = normalizeKey(expectedKey);
+  return actual === expected || actual.endsWith(`.${expected}`);
+}
+
+function normalizeKey(key: string): string {
+  return key.toLowerCase().replace(/[^a-z0-9.]/g, "");
+}
+
+function getStringField(record: Record<string, unknown>, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return undefined;
+}

package/lib/normalize.ts

@@ -0,0 +1,30 @@
+import type { AgentMessage, AssistantMessage, ToolCallContent } from "./types";
+
+function isObject(val: unknown): val is Record<string, unknown> {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+
+function normalizeToolCallBlock(block: unknown): ToolCallContent | null {
+  if (!isObject(block) || block.type !== "toolCall") return null;
+  return {
+    type: "toolCall",
+    toolCallId: typeof block.toolCallId === "string" ? block.toolCallId : (typeof block.id === "string" ? block.id : ""),
+    toolName: typeof block.toolName === "string" ? block.toolName : (typeof block.name === "string" ? block.name : ""),
+    input: typeof block.input === "object" && block.input !== null && !Array.isArray(block.input)
+      ? block.input as Record<string, unknown>
+      : (typeof block.arguments === "object" && block.arguments !== null && !Array.isArray(block.arguments)
+        ? block.arguments as Record<string, unknown>
+        : {}),
+  };
+}
+
+export function normalizeToolCalls(msg: AgentMessage): AgentMessage {
+  if (msg.role !== "assistant") return msg;
+  const content = (msg as AssistantMessage).content;
+  if (!Array.isArray(content)) return msg;
+  const normalized = content.map((block) => {
+    const result = normalizeToolCallBlock(block);
+    return result ?? block;
+  });
+  return { ...msg, content: normalized } as AgentMessage;
+}