@trim21/personal-pi-extensions 0.0.392 → 0.0.398

package/README.md

@@ -16,6 +16,7 @@
 | [todowrite](#todowrite)         | opencode 风格的任务列表工具，完整列表替换语义           |
 | [question](#question)           | opencode 风格的提问工具，阻塞式询问用户选择             |
 | [talk](#talk)                   | session 间消息传递，SQLite 邮箱 + 双向 ask 时间戳仲裁   |
+| [openai-cost](#openai-cost)     | OpenAI Chat Completions，费用取自响应 `usage.cost`      |
 
 > **两套工具风格，按预期只启用其中一套**：本包同时提供 opencode 风格
 > （小写 `read`/`edit`/`write`/`bash`/`todowrite`/`question`）与 Claude Code
@@ -387,6 +388,35 @@ read/edit/write 工具内置 LSP 诊断（写文件后等待并报告 ERROR 级
 
 ---
 
+## openai-cost
+
+OpenAI Chat Completions 兼容 provider。流式协议复用 pi 内置 `openai-completions`，费用不按模型单价估算，而是读取响应 `usage.cost`（number 或 `{ total }`，也认 Moonshot 的 `choice.usage`）写入 `message.usage.cost.total`。未上报 `usage.cost` 时保留默认 `calculateCost`。
+
+配置文件：`~/.pi/agent/openai-cost.json`。文件缺失或校验失败时扩展不注册 provider。
+
+```jsonc
+{
+  "id": "openai-cost", // 可选，默认 openai-cost
+  "name": "OpenAI Cost", // 可选
+  "baseUrl": "https://api.example.com/v1",
+  "apiKeyEnv": "OPENAI_COST_API_KEY", // 可选；也支持 /login
+  "models": [
+    {
+      "id": "my-model",
+      "name": "My Model", // 可选，默认用 id
+      "reasoning": false,
+      "input": ["text"],
+      "contextWindow": 128000,
+      "maxTokens": 8192,
+    },
+  ],
+}
+```
+
+省略 `models` 时启动后会请求 `GET {baseUrl}/models`，默认 `reasoning: false`、`input: ["text"]`、contextWindow 128000、maxTokens 8192。需要视觉 / reasoning / 准确窗口时把模型写进配置。API key 优先 stored credential，否则读 `apiKeyEnv`。
+
+---
+
 ## 安装
 
 ### 通过 npm/git 包

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.392",
+  "version": "0.0.398",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [
@@ -82,7 +82,7 @@
       "prettier --write"
     ]
   },
-  "packageManager": "pnpm@11.23.0",
+  "packageManager": "pnpm@11.24.0",
   "engines": {
     "node": ">=24"
   },

package/src/openai-cost/config.ts

@@ -0,0 +1,112 @@
+/**
+ * openai-cost 配置：~/.pi/agent/openai-cost.json
+ * 用 typebox 校验，解析失败或文件缺失时视为未配置。
+ */
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { type Static, Type } from "typebox";
+import { Value } from "typebox/value";
+
+export const DEFAULT_PROVIDER_ID = "openai-cost";
+export const DEFAULT_PROVIDER_NAME = "OpenAI Cost";
+export const DEFAULT_API_KEY_ENV = "OPENAI_COST_API_KEY";
+export const DEFAULT_CONTEXT_WINDOW = 128000;
+export const DEFAULT_MAX_TOKENS = 8192;
+export const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } as const;
+
+const modelSchema = Type.Object({
+  id: Type.String({ minLength: 1 }),
+  name: Type.Optional(Type.String()),
+  reasoning: Type.Optional(Type.Boolean()),
+  input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+  contextWindow: Type.Optional(Type.Number()),
+  maxTokens: Type.Optional(Type.Number()),
+  baseUrl: Type.Optional(Type.String()),
+});
+
+const configSchema = Type.Object({
+  id: Type.Optional(Type.String()),
+  name: Type.Optional(Type.String()),
+  baseUrl: Type.String({ minLength: 1 }),
+  apiKeyEnv: Type.Optional(Type.String()),
+  models: Type.Optional(Type.Array(modelSchema)),
+});
+
+type RawConfig = Static<typeof configSchema>;
+
+export interface OpenaiCostModelConfig {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: ("text" | "image")[];
+  contextWindow: number;
+  maxTokens: number;
+  baseUrl?: string;
+}
+
+export interface OpenaiCostConfig {
+  id: string;
+  name: string;
+  baseUrl: string;
+  apiKeyEnv: string;
+  models?: OpenaiCostModelConfig[];
+}
+
+export function openaiCostConfigPath(): string {
+  return join(homedir(), ".pi", "agent", "openai-cost.json");
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed || undefined;
+}
+
+function normalizeModel(model: Static<typeof modelSchema>): OpenaiCostModelConfig | undefined {
+  const id = nonEmpty(model.id);
+  if (!id) return undefined;
+  const input = model.input?.filter((value) => value === "text" || value === "image") ?? [];
+  return {
+    id,
+    name: nonEmpty(model.name) ?? id,
+    reasoning: model.reasoning ?? false,
+    input: input.length > 0 ? input : ["text"],
+    contextWindow:
+      model.contextWindow !== undefined && model.contextWindow > 0
+        ? model.contextWindow
+        : DEFAULT_CONTEXT_WINDOW,
+    maxTokens:
+      model.maxTokens !== undefined && model.maxTokens > 0 ? model.maxTokens : DEFAULT_MAX_TOKENS,
+    baseUrl: nonEmpty(model.baseUrl),
+  };
+}
+
+function normalize(raw: RawConfig): OpenaiCostConfig {
+  const models = raw.models
+    ?.map((model) => normalizeModel(model))
+    .filter((model): model is OpenaiCostModelConfig => model !== undefined);
+  return {
+    id: nonEmpty(raw.id) ?? DEFAULT_PROVIDER_ID,
+    name: nonEmpty(raw.name) ?? DEFAULT_PROVIDER_NAME,
+    baseUrl: raw.baseUrl.trim().replace(/\/+$/, ""),
+    apiKeyEnv: nonEmpty(raw.apiKeyEnv) ?? DEFAULT_API_KEY_ENV,
+    models: models && models.length > 0 ? models : undefined,
+  };
+}
+
+export async function loadOpenaiCostConfig(
+  path = openaiCostConfigPath(),
+): Promise<OpenaiCostConfig | undefined> {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+  try {
+    return normalize(Value.Parse(configSchema, raw));
+  } catch {
+    return undefined;
+  }
+}

package/src/openai-cost/cost.ts

@@ -0,0 +1,199 @@
+/**
+ * 从 Chat Completions SSE 里截取 usage.cost，写回 AssistantMessage.usage.cost.total。
+ * 内置 openai-completions 会用模型单价覆盖费用，必须在 fetch 层把上报值留下来。
+ */
+import {
+  type AssistantMessage,
+  type AssistantMessageEvent,
+  type AssistantMessageEventStream,
+  createAssistantMessageEventStream,
+  type Usage,
+} from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+
+export interface ReportedCostCapture {
+  fetch: typeof globalThis.fetch;
+  wait: () => Promise<number | undefined>;
+}
+
+function finiteNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+const usageCostSchema = Type.Object(
+  {
+    cost: Type.Optional(
+      Type.Union([
+        Type.Number(),
+        Type.Object({ total: Type.Optional(Type.Number()) }, { additionalProperties: true }),
+      ]),
+    ),
+  },
+  { additionalProperties: true },
+);
+
+const chunkSchema = Type.Object(
+  {
+    usage: Type.Optional(usageCostSchema),
+    choices: Type.Optional(
+      Type.Array(
+        Type.Object({ usage: Type.Optional(usageCostSchema) }, { additionalProperties: true }),
+      ),
+    ),
+  },
+  { additionalProperties: true },
+);
+
+function costFromUsage(
+  usage: { cost?: number | { total?: number } } | undefined,
+): number | undefined {
+  if (!usage) return undefined;
+  const asNumber = finiteNumber(usage.cost);
+  if (asNumber !== undefined) return asNumber;
+  if (usage.cost && typeof usage.cost === "object") return finiteNumber(usage.cost.total);
+  return undefined;
+}
+
+/** 从 chat completions JSON 块读取上报费用：usage.cost 或 choice.usage.cost。 */
+export function extractReportedCost(value: unknown): number | undefined {
+  let chunk;
+  try {
+    chunk = Value.Parse(chunkSchema, value);
+  } catch {
+    return undefined;
+  }
+  const fromUsage = costFromUsage(chunk.usage);
+  if (fromUsage !== undefined) return fromUsage;
+  for (const choice of chunk.choices ?? []) {
+    const fromChoice = costFromUsage(choice.usage);
+    if (fromChoice !== undefined) return fromChoice;
+  }
+  return undefined;
+}
+
+export function costFromSseLine(line: string): number | undefined {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) return undefined;
+  const data = trimmed.slice("data:".length).trim();
+  if (!data || data === "[DONE]") return undefined;
+  try {
+    return extractReportedCost(JSON.parse(data) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+export async function scanSseCost(body: ReadableStream<Uint8Array>): Promise<number | undefined> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let last: number | undefined;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const cost = costFromSseLine(line);
+        if (cost !== undefined) last = cost;
+      }
+    }
+    buffer += decoder.decode();
+    const cost = costFromSseLine(buffer);
+    if (cost !== undefined) last = cost;
+    return last;
+  } catch {
+    return last;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+type FetchInput = Parameters<typeof globalThis.fetch>[0];
+
+function requestUrl(input: FetchInput): string {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+
+function shouldScan(input: FetchInput, response: Response): boolean {
+  if (!response.ok || !response.body) return false;
+  if (requestUrl(input).includes("/chat/completions")) return true;
+  const contentType = response.headers.get("content-type") ?? "";
+  return contentType.includes("text/event-stream");
+}
+
+export function createReportedCostCapture(
+  innerFetch: typeof globalThis.fetch,
+): ReportedCostCapture {
+  let scan: Promise<number | undefined> | undefined;
+  const fetch: typeof globalThis.fetch = async (input, init) => {
+    const response = await innerFetch(input, init);
+    if (!shouldScan(input, response) || !response.body) return response;
+    const [forSdk, forScan] = response.body.tee();
+    scan = scanSseCost(forScan);
+    return new Response(forSdk, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+    });
+  };
+  return {
+    fetch,
+    wait: async () => (scan ? await scan : undefined),
+  };
+}
+
+export function applyReportedCost(usage: Usage, reported: number): void {
+  usage.cost.input = 0;
+  usage.cost.output = 0;
+  usage.cost.cacheRead = 0;
+  usage.cost.cacheWrite = 0;
+  usage.cost.total = reported;
+}
+
+function messageOf(event: AssistantMessageEvent): AssistantMessage {
+  if (event.type === "done") return event.message;
+  if (event.type === "error") return event.error;
+  return event.partial;
+}
+
+export function applyCostToEvent(
+  event: AssistantMessageEvent,
+  reported: number | undefined,
+): AssistantMessageEvent {
+  if (reported === undefined) return event;
+  applyReportedCost(messageOf(event).usage, reported);
+  return event;
+}
+
+export function wrapStreamWithReportedCost(
+  inner: AssistantMessageEventStream,
+  waitCost: () => Promise<number | undefined>,
+): AssistantMessageEventStream {
+  const out = createAssistantMessageEventStream();
+  void (async () => {
+    try {
+      for await (const event of inner) {
+        let reported: number | undefined;
+        if (event.type === "done" || event.type === "error") {
+          try {
+            reported = await waitCost();
+          } catch {
+            reported = undefined;
+          }
+        }
+        out.push(applyCostToEvent(event, reported));
+      }
+    } catch {
+      // inner already terminated or failed; result() follows the inner events
+    } finally {
+      out.end();
+    }
+  })();
+  return out;
+}

package/src/openai-cost/index.ts

@@ -0,0 +1,14 @@
+/**
+ * openai-cost —— OpenAI Chat Completions provider，费用取自响应 usage.cost，
+ * 不用模型单价估算。配置：~/.pi/agent/openai-cost.json。
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { loadOpenaiCostConfig } from "./config.js";
+import { createOpenaiCostProvider } from "./provider.js";
+
+export default async function openaiCostExtension(pi: ExtensionAPI) {
+  const config = await loadOpenaiCostConfig();
+  if (!config) return;
+  pi.registerProvider(createOpenaiCostProvider(config));
+}

package/src/openai-cost/provider.ts

@@ -0,0 +1,152 @@
+import process from "node:process";
+
+import {
+  createProvider,
+  envApiKeyAuth,
+  type Model,
+  type Provider,
+  type ProviderStreams,
+  type RefreshModelsContext,
+} from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { type Static, Type } from "typebox";
+import { Value } from "typebox/value";
+
+import {
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_TOKENS,
+  type OpenaiCostConfig,
+  type OpenaiCostModelConfig,
+  ZERO_COST,
+} from "./config.js";
+import { createReportedCostCapture, wrapStreamWithReportedCost } from "./cost.js";
+
+const remoteModelsSchema = Type.Object(
+  {
+    data: Type.Array(
+      Type.Object(
+        {
+          id: Type.String(),
+          name: Type.Optional(Type.String()),
+          context_window: Type.Optional(Type.Number()),
+          max_tokens: Type.Optional(Type.Number()),
+        },
+        { additionalProperties: true },
+      ),
+    ),
+  },
+  { additionalProperties: true },
+);
+
+type RemoteModels = Static<typeof remoteModelsSchema>;
+
+export function toPiModel(
+  config: OpenaiCostConfig,
+  model: OpenaiCostModelConfig,
+): Model<"openai-completions"> {
+  return {
+    id: model.id,
+    name: model.name,
+    api: "openai-completions",
+    provider: config.id,
+    baseUrl: model.baseUrl ?? config.baseUrl,
+    reasoning: model.reasoning,
+    input: model.input,
+    cost: { ...ZERO_COST },
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+  };
+}
+
+function modelsUrl(baseUrl: string): string {
+  return `${baseUrl.replace(/\/+$/, "")}/models`;
+}
+
+export function mapRemoteModels(
+  config: OpenaiCostConfig,
+  payload: RemoteModels,
+): Model<"openai-completions">[] {
+  const models: Model<"openai-completions">[] = [];
+  for (const item of payload.data) {
+    const id = item.id.trim();
+    if (!id) continue;
+    models.push(
+      toPiModel(config, {
+        id,
+        name: item.name?.trim() || id,
+        reasoning: false,
+        input: ["text"],
+        contextWindow:
+          item.context_window && item.context_window > 0
+            ? item.context_window
+            : DEFAULT_CONTEXT_WINDOW,
+        maxTokens: item.max_tokens && item.max_tokens > 0 ? item.max_tokens : DEFAULT_MAX_TOKENS,
+      }),
+    );
+  }
+  return models;
+}
+
+export async function fetchRemoteModels(
+  config: OpenaiCostConfig,
+  options: { apiKey?: string; signal?: AbortSignal; fetch?: typeof globalThis.fetch } = {},
+): Promise<Model<"openai-completions">[]> {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const headers: Record<string, string> = { Accept: "application/json" };
+  if (options.apiKey) headers.Authorization = `Bearer ${options.apiKey}`;
+  const response = await fetchImpl(modelsUrl(config.baseUrl), { headers, signal: options.signal });
+  const raw = await response.text();
+  if (!response.ok) {
+    throw new Error(`openai-cost /models ${response.status}: ${raw.slice(0, 300)}`);
+  }
+  return mapRemoteModels(config, Value.Parse(remoteModelsSchema, JSON.parse(raw) as unknown));
+}
+
+function withReportedCost(api: ProviderStreams): ProviderStreams {
+  const wrap = (
+    run: (fetch: typeof globalThis.fetch) => ReturnType<ProviderStreams["stream"]>,
+    fetch: typeof globalThis.fetch | undefined,
+  ) => {
+    const capture = createReportedCostCapture(fetch ?? globalThis.fetch);
+    return wrapStreamWithReportedCost(run(capture.fetch), capture.wait);
+  };
+  return {
+    stream: (model, context, options) =>
+      wrap((fetch) => api.stream(model, context, { ...options, fetch }), options?.fetch),
+    streamSimple: (model, context, options) =>
+      wrap((fetch) => api.streamSimple(model, context, { ...options, fetch }), options?.fetch),
+  };
+}
+
+function apiKeyFromRefresh(context: RefreshModelsContext, apiKeyEnv: string): string | undefined {
+  if (context.credential?.type === "api_key" && context.credential.key) {
+    return context.credential.key;
+  }
+  const envValue = process.env[apiKeyEnv];
+  return envValue?.trim() || undefined;
+}
+
+export function createOpenaiCostProvider(
+  config: OpenaiCostConfig,
+  options: { api?: ProviderStreams; fetch?: typeof globalThis.fetch } = {},
+): Provider<"openai-completions"> {
+  const api = withReportedCost(options.api ?? openAICompletionsApi());
+  const staticModels = config.models?.map((model) => toPiModel(config, model)) ?? [];
+  return createProvider({
+    id: config.id,
+    name: config.name,
+    baseUrl: config.baseUrl,
+    auth: { apiKey: envApiKeyAuth(`${config.name} API key`, [config.apiKeyEnv]) },
+    models: staticModels,
+    fetchModels:
+      staticModels.length > 0
+        ? undefined
+        : async (context) =>
+            fetchRemoteModels(config, {
+              apiKey: apiKeyFromRefresh(context, config.apiKeyEnv),
+              signal: context.signal,
+              fetch: options.fetch,
+            }),
+    api,
+  });
+}