@coze-arch/cli 0.0.18 → 0.0.19-beta.1

package/lib/__templates__/pi-agent/src/config.ts

@@ -0,0 +1,708 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getModel, type Api, type Model } from "@mariozechner/pi-ai";
+import type { BotAppConfig, ThinkingLevel } from "./core.js";
+
+type ModelInput = "text" | "image";
+
+interface ModelCost {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+interface ModelOverride {
+  name?: string;
+  reasoning?: boolean;
+  input?: ModelInput[];
+  cost?: Partial<ModelCost>;
+  contextWindow?: number;
+  maxTokens?: number;
+  headers?: Record<string, string>;
+  compat?: Model<Api>["compat"];
+}
+
+interface ProviderModelConfig {
+  id: string;
+  name?: string;
+  api?: Api;
+  baseUrl?: string;
+  reasoning?: boolean;
+  input?: ModelInput[];
+  cost?: ModelCost;
+  contextWindow?: number;
+  maxTokens?: number;
+  headers?: Record<string, string>;
+  compat?: Model<Api>["compat"];
+}
+
+export interface ProviderConfig {
+  api?: Api;
+  apiKey?: string;
+  baseUrl?: string;
+  headers?: Record<string, string>;
+  compat?: Model<Api>["compat"];
+  authHeader?: boolean;
+  modelOverrides?: Record<string, ModelOverride>;
+  models?: ProviderModelConfig[];
+}
+
+export interface Config {
+  agents?: {
+    defaults?: {
+      model?: {
+        primary?: string;
+      };
+      thinkingLevel?: ThinkingLevel;
+      workspace?: string;
+    };
+  };
+  models?: {
+    providers?: Record<string, ProviderConfig>;
+  };
+  channels?: {
+    feishu?: {
+      enabled?: boolean;
+      appId?: string;
+      appSecret?: string;
+      domain?: string;
+      encryptKey?: string;
+      verificationToken?: string;
+      requireMention?: boolean;
+      thinkingReaction?: {
+        enabled?: boolean;
+        emojiType?: string;
+      };
+    };
+    wechat?: {
+      enabled?: boolean;
+      requireMention?: boolean;
+    };
+  };
+}
+
+export interface ModelReference {
+  provider: string;
+  modelId: string;
+}
+
+export interface LoadedConfig {
+  path: string;
+  directory: string;
+  workspaceDir: string;
+  thinkingLevel?: ThinkingLevel;
+  config: Config;
+  providers: Record<string, ProviderConfig>;
+  defaultModel?: ModelReference;
+}
+
+export interface ResolvedRuntimeModel {
+  model: Model<Api>;
+  apiKey?: string;
+}
+
+export interface ResolveRuntimeModelOptions {
+  provider?: string;
+  model?: string;
+  baseUrl?: string;
+  configPath?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface LoadBotAppConfigOptions {
+  configPath?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+const DEFAULT_COST: ModelCost = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0
+};
+const DEFAULT_APP_NAME = "starter-bot";
+const DEFAULT_CONFIG_FILENAME = "config.json";
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+
+export function parseModelReference(reference: string, description = "model reference"): ModelReference {
+  const normalized = reference.trim();
+  const splitIndex = normalized.indexOf("/");
+
+  if (splitIndex <= 0 || splitIndex === normalized.length - 1) {
+    throw new Error(
+      `${description} must use "provider/model-id" format, received "${reference}".`
+    );
+  }
+
+  return {
+    provider: normalized.slice(0, splitIndex),
+    modelId: normalized.slice(splitIndex + 1)
+  };
+}
+
+export function loadConfig(configPath: string): LoadedConfig {
+  if (!existsSync(configPath)) {
+    throw new Error(`Config not found: ${configPath}`);
+  }
+
+  let parsed: Config;
+
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf-8")) as Config;
+  } catch (error) {
+    throw new Error(
+      `Failed to read config at ${configPath}: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+
+  const directory = dirname(configPath);
+  const workspaceDir = resolve(directory, parsed.agents?.defaults?.workspace ?? ".");
+  const defaultModelReference = parsed.agents?.defaults?.model?.primary;
+
+  return {
+    path: configPath,
+    directory,
+    workspaceDir,
+    thinkingLevel: parsed.agents?.defaults?.thinkingLevel,
+    config: parsed,
+    providers: parsed.models?.providers ?? {},
+    defaultModel: defaultModelReference
+      ? parseModelReference(defaultModelReference, "agents.defaults.model.primary")
+      : undefined
+  };
+}
+
+export function loadOptionalConfig(configPath: string | undefined): LoadedConfig | undefined {
+  if (!configPath || !existsSync(configPath)) {
+    return undefined;
+  }
+
+  return loadConfig(configPath);
+}
+
+export function resolveRuntimeModel(
+  options: ResolveRuntimeModelOptions
+): ResolvedRuntimeModel | undefined {
+  const loadedConfig = loadOptionalConfig(options.configPath);
+  const selection = resolveModelSelection(options, loadedConfig);
+
+  if (!selection) {
+    return undefined;
+  }
+
+  const providerConfig = loadedConfig?.providers[selection.provider];
+
+  if (providerConfig) {
+    return createConfiguredProviderModel({
+      provider: selection.provider,
+      modelId: selection.modelId,
+      providerConfig,
+      explicitBaseUrl: options.baseUrl,
+      configPath: loadedConfig.path,
+      env: options.env
+    });
+  }
+
+  const builtInModel = getModel(selection.provider as never, selection.modelId);
+  if (!builtInModel) {
+    throw new Error(
+      `Unknown provider/model "${selection.provider}/${selection.modelId}". ` +
+        `It was not found in config.json or built-in pi-ai models.`
+    );
+  }
+
+  return {
+    model: applyBaseUrlOverride(cloneModel(builtInModel), options.baseUrl)
+  };
+}
+
+function resolveModelSelection(
+  options: ResolveRuntimeModelOptions,
+  loadedConfig: LoadedConfig | undefined
+): ModelReference | undefined {
+  if (options.provider && options.model) {
+    return {
+      provider: options.provider,
+      modelId: options.model
+    };
+  }
+
+  if (!options.provider && options.model?.includes("/")) {
+    return parseModelReference(options.model, "agent.model");
+  }
+
+  return loadedConfig?.defaultModel;
+}
+
+export function getProjectRoot(): string {
+  return resolve(MODULE_DIR, "..");
+}
+
+export function getDefaultConfigPath(): string {
+  const projectRoot = getProjectRoot();
+  return resolve(projectRoot, "<%= workspaceDir %>", DEFAULT_CONFIG_FILENAME);
+}
+
+export function loadBotAppConfig(
+  options: LoadBotAppConfigOptions = {}
+): BotAppConfig {
+  const env = options.env ?? process.env;
+  const configPath = options.configPath ?? getDefaultConfigPath();
+  const loadedConfig = loadConfig(configPath);
+  const workspaceDir = loadedConfig.workspaceDir;
+  const defaultModel = loadedConfig.defaultModel;
+  const feishuCfg = loadedConfig.config.channels?.feishu;
+  const wechatCfg = loadedConfig.config.channels?.wechat;
+
+  return {
+    appName: DEFAULT_APP_NAME,
+    agent: {
+      mode: (env.PI_BOT_AGENT_MODE as BotAppConfig["agent"]["mode"] | undefined) ?? "pi",
+      provider: defaultModel?.provider ?? "openai",
+      model: defaultModel?.modelId ?? "gpt-5-mini",
+      configPath,
+      thinkingLevel: loadedConfig.thinkingLevel,
+      cwd: workspaceDir,
+      agentDir: workspaceDir
+    },
+    routing: {
+      feishuGroupRequireMention: feishuCfg?.requireMention ?? true,
+      wechatGroupRequireMention: wechatCfg?.requireMention ?? false
+    },
+    channels: {
+      feishu: {
+        enabled: feishuCfg?.enabled ?? false,
+        appId: resolveOptionalRuntimeValue(feishuCfg?.appId, "channels.feishu.appId", env),
+        appSecret: resolveOptionalRuntimeValue(feishuCfg?.appSecret, "channels.feishu.appSecret", env),
+        domain: resolveOptionalRuntimeValue(feishuCfg?.domain, "channels.feishu.domain", env),
+        encryptKey: resolveOptionalRuntimeValue(feishuCfg?.encryptKey, "channels.feishu.encryptKey", env),
+        verificationToken: resolveOptionalRuntimeValue(feishuCfg?.verificationToken, "channels.feishu.verificationToken", env),
+        thinkingReaction: {
+          enabled: feishuCfg?.thinkingReaction?.enabled ?? true,
+          emojiType: feishuCfg?.thinkingReaction?.emojiType
+        }
+      },
+      wechat: {
+        enabled: wechatCfg?.enabled ?? false
+      }
+    }
+  };
+}
+
+function createConfiguredProviderModel(options: {
+  provider: string;
+  modelId: string;
+  providerConfig: ProviderConfig;
+  explicitBaseUrl?: string;
+  configPath: string;
+  env?: NodeJS.ProcessEnv;
+}): ResolvedRuntimeModel {
+  const explicitBaseUrl = options.explicitBaseUrl
+    ? resolveRuntimeValue(
+        options.explicitBaseUrl,
+        `${options.provider}/${options.modelId} baseUrl override`,
+        options.env
+      )
+    : undefined;
+  const apiKey = options.providerConfig.apiKey
+    ? resolveRuntimeValue(
+        options.providerConfig.apiKey,
+        `${options.provider} apiKey in ${options.configPath}`,
+        options.env
+      )
+    : undefined;
+  const providerHeaders = resolveHeaders(
+    options.providerConfig.headers,
+    `${options.provider} headers in ${options.configPath}`,
+    options.env
+  );
+  const override = options.providerConfig.modelOverrides?.[options.modelId];
+  const customModel = options.providerConfig.models?.find((model) => model.id === options.modelId);
+
+  let model: Model<Api>;
+
+  if (customModel) {
+    const api = customModel.api ?? options.providerConfig.api;
+    const baseUrl =
+      explicitBaseUrl ??
+      resolveOptionalRuntimeValue(
+        customModel.baseUrl ?? options.providerConfig.baseUrl,
+        `${options.provider}/${options.modelId} baseUrl in ${options.configPath}`,
+        options.env
+      );
+
+    if (!api) {
+      throw new Error(
+        `Provider "${options.provider}" model "${options.modelId}" is missing an api field in ${options.configPath}.`
+      );
+    }
+
+    if (!baseUrl) {
+      throw new Error(
+        `Provider "${options.provider}" model "${options.modelId}" is missing a baseUrl in ${options.configPath}.`
+      );
+    }
+
+    model = {
+      id: customModel.id,
+      name: customModel.name ?? customModel.id,
+      api,
+      provider: options.provider,
+      baseUrl,
+      reasoning: customModel.reasoning ?? false,
+      input: [...(customModel.input ?? ["text"])],
+      cost: { ...(customModel.cost ?? DEFAULT_COST) },
+      contextWindow: customModel.contextWindow ?? 128000,
+      maxTokens: customModel.maxTokens ?? 16384,
+      headers: mergeHeaders(
+        providerHeaders,
+        resolveHeaders(
+          customModel.headers,
+          `${options.provider}/${options.modelId} headers in ${options.configPath}`,
+          options.env
+        )
+      ),
+      compat: mergeCompat(options.providerConfig.compat, customModel.compat)
+    };
+  } else {
+    const builtInModel = getModel(options.provider as never, options.modelId);
+    if (!builtInModel) {
+      const availableModels = new Set<string>();
+
+      for (const configuredModel of options.providerConfig.models ?? []) {
+        availableModels.add(configuredModel.id);
+      }
+
+      throw new Error(
+        `Unknown model "${options.provider}/${options.modelId}" in ${options.configPath}. ` +
+          `Configured models: ${Array.from(availableModels).sort().join(", ") || "(none)"}`
+      );
+    }
+
+    model = cloneModel(builtInModel);
+    model.baseUrl =
+      explicitBaseUrl ??
+      resolveOptionalRuntimeValue(
+        options.providerConfig.baseUrl,
+        `${options.provider} baseUrl in ${options.configPath}`,
+        options.env
+      ) ??
+      model.baseUrl;
+    model.headers = mergeHeaders(model.headers, providerHeaders);
+    model.compat = mergeCompat(model.compat, options.providerConfig.compat);
+  }
+
+  model = applyModelOverride(
+    model,
+    override,
+    `${options.provider}/${options.modelId} override in ${options.configPath}`,
+    options.env
+  );
+
+  if (options.providerConfig.authHeader && apiKey) {
+    model.headers = mergeHeaders(model.headers, {
+      Authorization: `Bearer ${apiKey}`
+    });
+    return { model };
+  }
+
+  return { model, apiKey };
+}
+
+function cloneModel(model: Model<Api>): Model<Api> {
+  return {
+    ...model,
+    input: [...model.input],
+    cost: { ...model.cost },
+    headers: model.headers ? { ...model.headers } : undefined,
+    compat: model.compat ? mergeCompat(model.compat) : undefined
+  };
+}
+
+function applyBaseUrlOverride(model: Model<Api>, baseUrl: string | undefined): Model<Api> {
+  if (!baseUrl) {
+    return model;
+  }
+
+  return {
+    ...model,
+    baseUrl
+  };
+}
+
+function applyModelOverride(
+  model: Model<Api>,
+  override: ModelOverride | undefined,
+  description: string,
+  env: NodeJS.ProcessEnv = process.env
+): Model<Api> {
+  if (!override) {
+    return model;
+  }
+
+  const nextModel = cloneModel(model);
+
+  if (override.name !== undefined) nextModel.name = override.name;
+  if (override.reasoning !== undefined) nextModel.reasoning = override.reasoning;
+  if (override.input !== undefined) nextModel.input = [...override.input];
+  if (override.contextWindow !== undefined) nextModel.contextWindow = override.contextWindow;
+  if (override.maxTokens !== undefined) nextModel.maxTokens = override.maxTokens;
+
+  if (override.cost) {
+    nextModel.cost = {
+      input: override.cost.input ?? nextModel.cost.input,
+      output: override.cost.output ?? nextModel.cost.output,
+      cacheRead: override.cost.cacheRead ?? nextModel.cost.cacheRead,
+      cacheWrite: override.cost.cacheWrite ?? nextModel.cost.cacheWrite
+    };
+  }
+
+  nextModel.headers = mergeHeaders(
+    nextModel.headers,
+    resolveHeaders(override.headers, `${description} headers`, env)
+  );
+  nextModel.compat = mergeCompat(nextModel.compat, override.compat);
+
+  return nextModel;
+}
+
+function mergeCompat(
+  base?: Model<Api>["compat"],
+  override?: Model<Api>["compat"]
+): Model<Api>["compat"] | undefined {
+  if (!base && !override) {
+    return undefined;
+  }
+
+  const merged = {
+    ...(base ?? {}),
+    ...(override ?? {})
+  } as Record<string, unknown>;
+
+  const baseRecord = (base ?? {}) as Record<string, unknown>;
+  const overrideRecord = (override ?? {}) as Record<string, unknown>;
+
+  if (isPlainObject(baseRecord.openRouterRouting) || isPlainObject(overrideRecord.openRouterRouting)) {
+    merged.openRouterRouting = {
+      ...(isPlainObject(baseRecord.openRouterRouting) ? baseRecord.openRouterRouting : {}),
+      ...(isPlainObject(overrideRecord.openRouterRouting) ? overrideRecord.openRouterRouting : {})
+    };
+  }
+
+  if (isPlainObject(baseRecord.vercelGatewayRouting) || isPlainObject(overrideRecord.vercelGatewayRouting)) {
+    merged.vercelGatewayRouting = {
+      ...(isPlainObject(baseRecord.vercelGatewayRouting) ? baseRecord.vercelGatewayRouting : {}),
+      ...(isPlainObject(overrideRecord.vercelGatewayRouting)
+        ? overrideRecord.vercelGatewayRouting
+        : {})
+    };
+  }
+
+  if (isPlainObject(baseRecord.reasoningEffortMap) || isPlainObject(overrideRecord.reasoningEffortMap)) {
+    merged.reasoningEffortMap = {
+      ...(isPlainObject(baseRecord.reasoningEffortMap) ? baseRecord.reasoningEffortMap : {}),
+      ...(isPlainObject(overrideRecord.reasoningEffortMap) ? overrideRecord.reasoningEffortMap : {})
+    };
+  }
+
+  return merged as Model<Api>["compat"];
+}
+
+function mergeHeaders(
+  ...headersList: Array<Record<string, string> | undefined>
+): Record<string, string> | undefined {
+  const merged = headersList.reduce<Record<string, string>>((acc, headers) => {
+    if (!headers) {
+      return acc;
+    }
+
+    return { ...acc, ...headers };
+  }, {});
+
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+
+function resolveHeaders(
+  headers: Record<string, string> | undefined,
+  description: string,
+  env: NodeJS.ProcessEnv = process.env
+): Record<string, string> | undefined {
+  if (!headers) {
+    return undefined;
+  }
+
+  const resolvedHeaders = Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      key,
+      resolveRuntimeValue(value, `${description} header "${key}"`, env)
+    ])
+  );
+
+  return Object.keys(resolvedHeaders).length > 0 ? resolvedHeaders : undefined;
+}
+
+function resolveOptionalRuntimeValue(
+  value: string | undefined,
+  description: string,
+  env: NodeJS.ProcessEnv = process.env
+): string | undefined {
+  return value ? resolveRuntimeValue(value, description, env) : undefined;
+}
+
+function resolveRuntimeValue(
+  value: string,
+  description: string,
+  env: NodeJS.ProcessEnv = process.env
+): string {
+  if (value.startsWith("!")) {
+    try {
+      const output = execSync(value.slice(1), {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+
+      if (!output) {
+        throw new Error("command returned empty output");
+      }
+
+      return output;
+    } catch (error) {
+      throw new Error(
+        `Failed to resolve ${description} from command "${value.slice(1)}": ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  return value.replace(/\$\{([A-Z0-9_]+)\}/g, (_, variableName: string) => {
+    const resolved = env[variableName];
+
+    if (!resolved) {
+      throw new Error(`Missing environment variable ${variableName} while resolving ${description}.`);
+    }
+
+    return resolved;
+  });
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function ensureObject(value: unknown): Record<string, unknown> {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return {};
+}
+
+export function readString(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function isArrayIndex(segment: string): boolean {
+  return /^\d+$/.test(segment);
+}
+
+export function getNested(root: Record<string, unknown>, path: string[]): unknown {
+  let current: unknown = root;
+  for (const segment of path) {
+    if (current === null || current === undefined) return undefined;
+    if (Array.isArray(current)) {
+      if (!isArrayIndex(segment)) return undefined;
+      current = current[Number(segment)];
+    } else if (typeof current === "object") {
+      current = (current as Record<string, unknown>)[segment];
+    } else {
+      return undefined;
+    }
+  }
+  return current;
+}
+
+export function setNested(root: Record<string, unknown>, path: string[], value: unknown): void {
+  let current: unknown = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const segment = path[i]!;
+    const nextSegment = path[i + 1]!;
+    if (Array.isArray(current)) {
+      if (!isArrayIndex(segment)) {
+        throw new Error(`Invalid array index "${segment}" in path "${path.join(".")}"`);
+      }
+      const index = Number(segment);
+      if (current[index] === undefined || current[index] === null || typeof current[index] !== "object") {
+        current[index] = isArrayIndex(nextSegment) ? [] : {};
+      }
+      current = current[index];
+    } else if (current && typeof current === "object") {
+      const obj = current as Record<string, unknown>;
+      if (obj[segment] === undefined || obj[segment] === null || typeof obj[segment] !== "object") {
+        obj[segment] = isArrayIndex(nextSegment) ? [] : {};
+      }
+      current = obj[segment];
+    }
+  }
+
+  const lastSegment = path[path.length - 1]!;
+  if (Array.isArray(current)) {
+    if (!isArrayIndex(lastSegment)) {
+      throw new Error(`Invalid array index "${lastSegment}" in path "${path.join(".")}"`);
+    }
+    current[Number(lastSegment)] = value;
+  } else if (current && typeof current === "object") {
+    (current as Record<string, unknown>)[lastSegment] = value;
+  }
+}
+
+export function deleteNested(root: Record<string, unknown>, path: string[]): boolean {
+  let current: unknown = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const segment = path[i]!;
+    if (Array.isArray(current)) {
+      if (!isArrayIndex(segment)) return false;
+      current = current[Number(segment)];
+    } else if (current && typeof current === "object") {
+      current = (current as Record<string, unknown>)[segment];
+    } else {
+      return false;
+    }
+    if (current === null || current === undefined) return false;
+  }
+
+  const lastSegment = path[path.length - 1]!;
+  if (Array.isArray(current)) {
+    if (!isArrayIndex(lastSegment)) return false;
+    const index = Number(lastSegment);
+    if (index >= current.length) return false;
+    current.splice(index, 1);
+    return true;
+  }
+  if (current && typeof current === "object") {
+    const obj = current as Record<string, unknown>;
+    if (lastSegment in obj) {
+      delete obj[lastSegment];
+      return true;
+    }
+  }
+  return false;
+}
+
+export function updateString(root: Record<string, unknown>, path: string[], value: unknown): void {
+  if (value === undefined) return;
+  if (typeof value === "string" && value.trim() === "") {
+    deleteNested(root, path);
+    return;
+  }
+  setNested(root, path, value);
+}
+
+export function updateBool(root: Record<string, unknown>, path: string[], value: unknown): void {
+  if (value === undefined) return;
+  setNested(root, path, Boolean(value));
+}