给智能体接入模型

// packages/ai/src/models.ts
getModel(provider: string, id: string): Model<Api> | undefined {
  return this.getModels(provider).find((model) => model.id === id);
}

// 打印当前 provider 的全部模型 id
for (const m of models.getModels("deepseek")) {
  console.log(`${m.id}  ${m.name}  context=${m.contextWindow}  maxTokens=${m.maxTokens}`);
}

import { createModels, createProvider, envApiKeyAuth, type Model } from "@earendil-works/pi-ai"
import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy"

const baseUrl = process.env.DEEPSEEK_BASE_URL || "https://api.deepseek.com/v1"
const model: Model<"openai-completions"> = {
  id: process.env.MODEL_ID || "deepseek-flash",
  name: "DeepSeek",
  provider: "deepseek",
  api: "openai-completions",
  baseUrl,
  reasoning: false,
  input: ["text"],
  // 下面两个数值按 DeepSeek 官方文档填写，这里只是占位。
  contextWindow: 65536,
  maxTokens: 4096,
  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
}

const models = createModels()
models.setProvider(
  createProvider({
    id: "deepseek",
    auth: { apiKey: envApiKeyAuth("DeepSeek", ["DEEPSEEK_API_KEY"]) },
    models: [model],
    api: openAICompletionsApi(),
  }),
)

import { createModels, type Context } from "@earendil-works/pi-ai"
import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek"

const models = createModels()
models.setProvider(deepseekProvider())

const modelId = process.env.MODEL_ID || "deepseek-flash"
const model = models.getModel("deepseek", modelId)
if (!model) {
  // 先把目录里真实存在的 id 打印出来，便于对照拼写
  console.error("目录中的 id：", models.getModels("deepseek").map((m) => m.id).join(", "))
  throw new Error(`模型目录中不存在：${modelId}`)
}

// Context 的形状：systemPrompt 可选，messages 必填，tools 可选。
// 直接调用模型层时，systemPrompt 与 tools 是 context 上的独立字段；
// 交给 Agent 之后，它们会被折叠进 transcript 里的 system 消息。
const context: Context = {
  messages: [{ role: "user", content: "只回复：连接成功", timestamp: Date.now() }],
}

const result = await models.completeSimple(model, context, {
  apiKey: process.env.DEEPSEEK_API_KEY,
  signal: AbortSignal.timeout(30_000),
})

if (result.stopReason === "error" || result.stopReason === "aborted") {
  throw new Error(result.errorMessage || result.stopReason)
}
for (const block of result.content) {
  if (block.type === "text") {
    console.log(block.text)
  }
}
console.log("用量：", result.usage)

node --env-file=.env --import tsx src/connect-model.ts

// packages/ai/src/models.ts
async completeSimple(
  model: Model<Api>,
  context: Context,
  options?: ModelsSimpleStreamOptions,
): Promise<AssistantMessage> {
  return this.streamSimple(model, context, options).result();
}

// packages/ai/src/api/lazy.ts
setup()
  .then((inner) => forwardStream(outer, inner, observer, observeResult))
  .catch((error) => {
    const reason = signal?.aborted ? "aborted" : "error";
    const message = createSetupErrorMessage(model, error, startedAt, reason);
    const event: AssistantMessageEvent = { type: "error", reason, error: message };
    outer.push(event);
    observer?.onEvent?.(event);
    outer.end(message);
    observeResult(message);
  });

// packages/ai/src/models.ts
/** Check whether a provider has complete auth configuration without refreshing OAuth. */
checkAuth(providerId: string, options?: AuthOperationOptions): Promise<AuthCheck | undefined>;

// packages/ai/src/models.ts
checkAuth(providerId: string, options?: AuthOperationOptions): Promise<AuthCheck | undefined> {
  const signal = operationSignal(options?.signal);
  const check = (async () => {
    signal.throwIfAborted();
    const provider = this.providers.get(providerId);
    if (!provider) return undefined;
    return this.checkProviderAuth(provider, await this.readCredential(providerId, signal), signal);
  })();
  return raceWithAbortSignal(check, signal);
}

// src/check-connection.ts
import { createModels } from "@earendil-works/pi-ai"
import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek"

const models = createModels()
models.setProvider(deepseekProvider())

const modelId = process.env.MODEL_ID || "deepseek-flash"
const model = models.getModel("deepseek", modelId)
const auth = await models.checkAuth("deepseek")

console.log("模型 id 存在：", model !== undefined)
console.log("凭据配置完整：", auth !== undefined)
if (auth) {
  // source 是人类可读的来源标签，例如 "DEEPSEEK_API_KEY" 或 "stored credential"
  console.log("凭据类型：", auth.type, "来源：", auth.source)
}

if (!model) {
  console.error("→ 模型 id 不在目录里。目录中的 id：")
  console.error(models.getModels("deepseek").map((m) => m.id).join("\n"))
}
if (!auth) {
  console.error("→ 凭据未配置完整：检查环境变量、凭据存储或 OAuth 登录。")
}
if (model && auth) {
  console.log("→ 两项本地检查都通过；若请求仍失败，看服务返回的错误正文。")
}

node --env-file=.env --import tsx src/check-connection.ts

const providerAuth = await models.getAuth("deepseek")
if (providerAuth) {
  console.log(`配置来源：${providerAuth.source}`)
} else {
  console.log("未配置")
}

// packages/ai/src/auth/context.ts
export function defaultProviderAuthContext(): AuthContext {
  return {
    async env(name: string): Promise<string | undefined> {
      const value = getProcessEnv()?.[name];
      return typeof value === "string" && value.trim().length > 0 ? value : undefined;
    },
    // ...
  };
}

// packages/ai/src/env-api-keys.ts
const envMap: Record<string, string> = {
  deepseek: "DEEPSEEK_API_KEY",
  // ... 其它 provider ...
};

// packages/ai/src/models.ts
constructor(options?: CreateModelsOptions) {
  this.credentials = options?.credentials ?? new InMemoryCredentialStore();
  this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore();
  this.authContext = options?.authContext ?? defaultAuthContext();
  this.identity = options?.identity;
}

// packages/ai/src/models.ts
login(providerId: string, type: AuthType, interaction: AuthInteraction, options?: LoginOptions): Promise<Credential>;

await models.login("anthropic", "oauth", {
  prompt: async (p) => {
    // p.type: 'text' | 'secret' | 'select' | 'manual_code'
    return await askUser(p.message)
  },
  notify: (event) => {
    // event.type: 'info' | 'auth_url' | 'device_code' | 'progress'
    if (event.type === "auth_url") console.log("打开：", event.url)
    if (event.type === "device_code") console.log("验证码：", event.userCode, "at", event.verificationUri)
  },
})

const models = createModels()
models.setProvider(deepseekProvider())
const model = models.getModel("deepseek", modelId)
if (!model) {
  throw new Error(`模型目录中不存在：${modelId}`)
}
const agent = new Agent({
  initialState: { systemPrompt, model, tools },
  streamFn: models.streamSimple.bind(models),
  getApiKey: () => apiKey,
})

// packages/agent/src/agent.ts
getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;

// packages/agent/src/agent-loop.ts
const resolvedApiKey =
  (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;