export type ModelsErrorCode = "model_source" | "model_validation" | "provider" | "stream" | "auth" | "oauth";

export class ModelsError extends Error {
	readonly code: ModelsErrorCode;

	constructor(code: ModelsErrorCode, message: string, options?: { cause?: unknown }) {
		super(withCauseDetail(message, options?.cause), options);
		this.name = "ModelsError";
		this.code = code;
	}
}

/** Callers surface `error.message` only, so keep the underlying reason in it. */
function withCauseDetail(message: string, cause: unknown): string {
	if (cause === undefined || cause === null) return message;
	const detail = formatThrownValue(cause).trim();
	if (!detail || message.includes(detail)) return message;
	return `${message}: ${detail}`;
}

import { createModels } from "@earendil-works/pi-ai";
import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";

const models = createModels();
models.setProvider(anthropicProvider());

const providerId = "anthropic";
const modelId = "claude-sonnet-4-6";

if (!models.getProvider(providerId)) {
  console.error("Provider 未注册：", providerId);
  process.exit(1);
}
const model = models.getModel(providerId, modelId);
if (!model) {
  console.error(`目录中不存在：${providerId}/${modelId}`);
  console.error("该 Provider 当前目录中的模型：");
  for (const item of models.getModels(providerId)) {
    console.error("  -", item.id);
  }
  process.exit(1);
}
const check = await models.checkAuth(providerId);
if (!check) {
  console.error(`凭据未配置：${providerId}`);
  console.error("设置对应的环境变量，或调用 models.login() 走交互式登录。");
  process.exit(1);
}
console.log("凭据来源：", check.source, "| 类型：", check.type);

import { createConnection } from "./connection.js"

try {
  const { models, model } = createConnection()
  const result = await models.completeSimple(
    model,
    {
      messages: [{ role: "user", content: "用一句话解释变量。", timestamp: Date.now() }],
    },
    {
      signal: AbortSignal.timeout(15_000),
      maxTokens: 256,
      maxRetryDelayMs: 2_000,
    },
  )
  if (result.stopReason === "error" || result.stopReason === "aborted") {
    console.error("请求未完成：", result.stopReason)
    console.error("原因：", result.errorMessage || "服务未提供详细原因")
    process.exitCode = 1
  } else if (result.stopReason === "length") {
    console.error("输出达到上限，请调整任务或预算后重试")
    process.exitCode = 1
  } else if (result.stopReason === "toolUse") {
    console.error("模型请求了工具，本程序没有执行工具")
    process.exitCode = 1
  } else {
    for (const block of result.content) {
      if (block.type === "text") {
        console.log(block.text)
      }
    }
  }
} catch (error) {
  console.error("配置或请求初始化失败：", error instanceof Error ? error.message : String(error))
  process.exitCode = 1
}

node --env-file=.env --import tsx src/handle-errors.ts

import { ModelsError } from "@earendil-works/pi-ai";

function describeFailure(error: unknown): { code: string; hint: string } {
  if (!(error instanceof ModelsError)) {
    return { code: "unknown", hint: "非模型层错误，检查应用代码与网络栈。" };
  }
  switch (error.code) {
    case "provider":
      return { code: error.code, hint: "Provider 未注册或缺少该能力的实现。" };
    case "auth":
      return { code: error.code, hint: "凭据缺失或凭据存储不可用。" };
    case "oauth":
      return { code: error.code, hint: "OAuth 刷新失败，需要重新登录。" };
    case "stream":
      return { code: error.code, hint: "协议不匹配或传输层建立失败。" };
    case "model_source":
      return { code: error.code, hint: "模型目录来源不可达。" };
    case "model_validation":
      return { code: error.code, hint: "模型目录数据不合法。" };
  }
}

export { ModelsError, type ModelsErrorCode } from "./auth/resolve.ts";

/**
 * Resolve provider-scoped auth by provider id, or provider auth plus static
 * model headers when passed a model. Includes a source label for status UI.
 * Resolves `undefined` when the provider is unknown or unconfigured.
 * Rejects with `ModelsError`: code "oauth" when a token refresh fails (the
 * stored credential is preserved for retry; re-login fixes it), code "auth"
 * when api-key resolution or the credential store fails. Request paths
 * surface rejections as stream errors.
 */

// A refresh that has started survives cancellation or a superseding model refresh, so a
// rotated refresh token is always persisted. A newer refresh then sees the fresh credential.

const credential = await models.login("anthropic", "oauth", {
  prompt: async (p) => {
    // 返回用户输入的字符串
    return askUser(p);
  },
  notify: (event) => {
    console.error(event.type, event.message ?? "");
  },
});

const diagnostic = {
  configuredTransport: "auto",
  fallbackTransport: "sse",       // 仅流开始前失败时出现
  eventsEmitted: false,
  phase: "before_message_stream_start",
  requestBytes: 1234,
};