@henjicc/ai-sdk 0.2.8

package/dist/generation/core.js

@@ -0,0 +1,318 @@
+import { flattenRuntimeParams } from '../catalog/consumer-contract.js';
+import { createModelIndex } from '../catalog/model-index.js';
+import { buildRequest, resolveRequestEndpoint } from '../protocols/request-builder-dsl.js';
+import { normalizeRequestBody } from '../protocols/request-normalizer.js';
+import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+import { resolveRuntimeContext, } from '../runtime/RuntimeContext.js';
+import { cancelTask, clearCancelFlag, registerAbortController, } from '../runtime/task-registry.js';
+/** 创建不含任何内置模型或供应商的生成客户端。 */
+export function createModularGenerationClient(config) {
+    const modules = collectModules(config);
+    return createGenerationClientCore({
+        runtime: config.runtime,
+        models: modules.models,
+        providers: modules.providers,
+    });
+}
+/** @internal 默认全量入口也委托这一份生成内核。 */
+export function createGenerationClientCore(config) {
+    const runtime = resolveRuntimeContext(config.runtime);
+    const modelIndex = createModelIndex(config.models);
+    const providers = createProviderIndex(config.providers);
+    let disposed = false;
+    const ensureActive = () => {
+        if (disposed)
+            throw new AiRuntimeError('client_disposed', 'AI client has been disposed');
+    };
+    const clientCatalog = {
+        get(modelId) {
+            ensureActive();
+            return modelIndex.get(modelId);
+        },
+        list() {
+            ensureActive();
+            return modelIndex.list();
+        },
+        listByType(type) {
+            ensureActive();
+            return modelIndex.list().filter((model) => model.meta.type === type);
+        },
+        listByProvider(providerId) {
+            ensureActive();
+            return modelIndex.list().filter((model) => model.meta.provider === providerId);
+        },
+        listByTag(tag) {
+            ensureActive();
+            return modelIndex.list().filter((model) => model.meta.tags?.includes(tag));
+        },
+        getDefaultValues(modelId) {
+            ensureActive();
+            const model = resolveModel(modelIndex, modelId);
+            return {
+                ...collectParamDefaults(model.params),
+                ...mergeAliasParamDefaults(modelId, {}, model),
+            };
+        },
+        getParams(modelId) {
+            ensureActive();
+            return resolveModel(modelIndex, modelId).params;
+        },
+        estimatePrice(modelId, params = {}) {
+            ensureActive();
+            const model = resolveModel(modelIndex, modelId);
+            if (model.pricing.fixed !== undefined)
+                return model.pricing.fixed;
+            const effectiveParams = {
+                ...collectParamDefaults(model.params),
+                ...mergeAliasParamDefaults(modelId, params, model),
+            };
+            return model.pricing.calculator?.(effectiveParams) ?? 0;
+        },
+        resolveParams(modelId, params = {}) {
+            ensureActive();
+            return mergeAliasParamDefaults(modelId, params, resolveModel(modelIndex, modelId));
+        },
+    };
+    return {
+        async generate(request, hooks = {}) {
+            ensureActive();
+            return await executeGeneration(modelIndex, providers, runtime, request, hooks);
+        },
+        async continuePolling(request, hooks = {}) {
+            ensureActive();
+            return await executePolling(modelIndex, providers, runtime, request, hooks);
+        },
+        cancel(request) {
+            ensureActive();
+            cancelTask(request.namespace, request.taskId);
+        },
+        catalog: clientCatalog,
+        providers: {
+            list() {
+                ensureActive();
+                return [...providers.keys()];
+            },
+            async testConnection(providerId) {
+                ensureActive();
+                const provider = resolveProvider(providers, providerId);
+                if (provider.testConnection)
+                    return await provider.testConnection(runtime);
+                const startedAt = Date.now();
+                const configured = Boolean(await runtime.credentials.get('generation', providerId));
+                return {
+                    providerId,
+                    status: configured ? 'saved_unverified' : 'not_configured',
+                    verified: false,
+                    checkedAt: new Date().toISOString(),
+                    durationMs: Math.max(0, Date.now() - startedAt),
+                };
+            },
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            config.onDispose?.();
+        },
+    };
+}
+function collectModules(config) {
+    const models = [...(config.models ?? [])];
+    const providers = [...(config.providers ?? [])];
+    const providersById = new Map();
+    for (const provider of providers) {
+        if (!providersById.has(provider.id))
+            providersById.set(provider.id, provider);
+    }
+    for (const pack of config.packs ?? []) {
+        models.push(...pack.models);
+        for (const provider of pack.providers) {
+            const existing = providersById.get(provider.id);
+            if (existing && isEquivalentProviderRegistration(existing, provider))
+                continue;
+            providers.push(provider);
+            if (!existing)
+                providersById.set(provider.id, provider);
+        }
+    }
+    return { models, providers };
+}
+function isEquivalentProviderRegistration(left, right) {
+    return left.adapter === right.adapter &&
+        left.preprocess === right.preprocess &&
+        left.testConnection === right.testConnection;
+}
+function createProviderIndex(registrations) {
+    const providers = new Map();
+    for (const registration of registrations) {
+        const id = registration.id.trim();
+        if (!id)
+            throw new AiRuntimeError('invalid_provider_id', 'Provider id must be a non-empty string');
+        if (providers.has(id)) {
+            throw new AiRuntimeError('provider_already_registered', `Provider already registered: ${id}`);
+        }
+        providers.set(id, registration);
+    }
+    return providers;
+}
+async function executeGeneration(modelIndex, providers, runtime, request, hooks) {
+    const requestId = request.requestId?.trim() || `${request.modelId}-${Date.now()}`;
+    const model = resolveModel(modelIndex, request.modelId);
+    const effectiveParams = mergeAliasParamDefaults(request.modelId, request.params, model);
+    const providerId = model.meta.provider;
+    const provider = resolveProvider(providers, providerId);
+    const controller = new AbortController();
+    const span = runtime.tracer.startSpan('generation.generate', {
+        requestId,
+        modelId: request.modelId,
+        providerId,
+    });
+    clearCancelFlag('generation', requestId);
+    registerAbortController('generation', requestId, controller);
+    try {
+        const apiKey = await requireApiKey(runtime, providerId);
+        const builtRequest = await buildRequest(effectiveParams, model);
+        if (!builtRequest.route.trim())
+            throw new AiRuntimeError('invalid_route', 'Request route is empty');
+        const normalizedBody = normalizeRequestBody(builtRequest.body, model.runtimeConstraints);
+        const requestBody = provider.preprocess
+            ? await provider.preprocess({
+                providerId,
+                route: builtRequest.route,
+                body: normalizedBody,
+                runtime,
+                params: effectiveParams,
+                model,
+                requestId,
+                signal: controller.signal,
+            })
+            : normalizedBody;
+        const info = {
+            requestId,
+            requestedModelId: request.modelId,
+            providerId,
+            route: builtRequest.route,
+            method: builtRequest.method,
+            requestBody,
+        };
+        hooks.onRequestBuilt?.(info);
+        const providerResult = await provider.adapter.execute({
+            apiKey,
+            route: builtRequest.route,
+            method: builtRequest.method,
+            body: requestBody,
+            requestId,
+            polling: model.meta.polling,
+            signal: controller.signal,
+            runtime,
+        });
+        const result = attachStructuredOutput(providerResult, model, effectiveParams);
+        hooks.onCompleted?.({ ...info, result });
+        span.end();
+        return result;
+    }
+    catch (error) {
+        span.end(error);
+        throw error;
+    }
+    finally {
+        clearCancelFlag('generation', requestId);
+    }
+}
+async function executePolling(modelIndex, providers, runtime, request, hooks) {
+    const taskId = request.taskId.trim();
+    const requestId = request.requestId?.trim() || `continue-${request.modelId}-${Date.now()}`;
+    const model = resolveModel(modelIndex, request.modelId);
+    const effectiveParams = mergeAliasParamDefaults(request.modelId, request.params ?? {}, model);
+    const providerId = model.meta.provider;
+    const provider = resolveProvider(providers, providerId);
+    const controller = new AbortController();
+    const span = runtime.tracer.startSpan('generation.continue-polling', {
+        requestId,
+        taskId,
+        modelId: request.modelId,
+        providerId,
+    });
+    clearCancelFlag('generation', taskId);
+    registerAbortController('generation', taskId, controller);
+    try {
+        const apiKey = await requireApiKey(runtime, providerId);
+        const endpoint = await resolveRequestEndpoint(effectiveParams, model);
+        const info = {
+            requestId,
+            requestedModelId: request.modelId,
+            providerId,
+            route: endpoint.route,
+            method: 'GET',
+            requestBody: {},
+        };
+        hooks.onRequestBuilt?.(info);
+        const providerResult = await provider.adapter.continuePolling({
+            apiKey,
+            route: endpoint.route,
+            taskId,
+            requestId,
+            polling: model.meta.polling,
+            signal: controller.signal,
+            runtime,
+        });
+        const result = attachStructuredOutput(providerResult, model, effectiveParams);
+        hooks.onCompleted?.({ ...info, result });
+        span.end();
+        return result;
+    }
+    catch (error) {
+        span.end(error);
+        throw error;
+    }
+    finally {
+        clearCancelFlag('generation', taskId);
+    }
+}
+function attachStructuredOutput(result, model, params) {
+    const parser = model.response?.structuredOutput;
+    if (!parser || result.status !== 'completed')
+        return result;
+    const structuredOutput = parser({
+        status: result.status,
+        url: result.url,
+        metadata: result.metadata,
+        params,
+    });
+    return structuredOutput ? { ...result, structuredOutput } : result;
+}
+function resolveProvider(providers, providerId) {
+    const provider = providers.get(providerId);
+    if (!provider)
+        throw new AiRuntimeError('unknown_provider', `Unknown provider: ${providerId}`);
+    return provider;
+}
+function resolveModel(modelIndex, modelId) {
+    const model = modelIndex.get(modelId);
+    if (!model) {
+        throw new AiRuntimeError('provider_not_found', `Unable to resolve provider for model: ${modelId}`);
+    }
+    return model;
+}
+function collectParamDefaults(params) {
+    return Object.fromEntries(flattenRuntimeParams(params).map((param) => [param.id, param.default]));
+}
+async function requireApiKey(runtime, providerId) {
+    const apiKey = await runtime.credentials.get('generation', providerId);
+    if (!apiKey) {
+        throw new AiRuntimeError('api_key_missing', `API key not configured for provider: ${providerId}`);
+    }
+    return apiKey;
+}
+function mergeAliasParamDefaults(requestedModelId, params, model) {
+    const normalizedParams = { ...params };
+    for (const mapping of Object.values(model.meta.aliasParamMappings ?? {})) {
+        for (const [legacyParamId, currentParamId] of Object.entries(mapping)) {
+            if (normalizedParams[currentParamId] === undefined && normalizedParams[legacyParamId] !== undefined) {
+                normalizedParams[currentParamId] = normalizedParams[legacyParamId];
+            }
+        }
+    }
+    const defaults = model.meta.aliasParamDefaults?.[requestedModelId];
+    return defaults ? { ...defaults, ...normalizedParams } : normalizedParams;
+}

package/dist/generation.d.ts

@@ -0,0 +1,20 @@
+import { type GenerationClient, type GenerationClientProviderRegistration } from './generation/core.js';
+import type { RuntimeContext } from './runtime/RuntimeContext.js';
+import type { ModelRuntimeDefinition } from './types/model.js';
+export * from './generation/core.js';
+/**
+ * 兼容入口的配置：`models` 与 `providers` 仍在默认 100 模型/8 供应商上追加。
+ * 需要真正零内置依赖或严格选择模型时，请改用 `generation/core`。
+ */
+export interface CreateGenerationClientConfig {
+    runtime: RuntimeContext;
+    providers?: readonly GenerationClientProviderRegistration[];
+    models?: readonly ModelRuntimeDefinition[];
+}
+/**
+ * 创建默认含 100 个生成模型的兼容客户端。
+ *
+ * 这里仅负责装配旧的全量 catalog 与进程级 provider registry；所有目录、请求、取消和
+ * 生命周期行为都委托 `generation/core` 的唯一生成内核。
+ */
+export declare function createGenerationClient(config: CreateGenerationClientConfig): GenerationClient;

package/dist/generation.js

@@ -0,0 +1,58 @@
+import { catalog } from './catalog/index.js';
+import { createGenerationClientCore, } from './generation/core.js';
+import { executeContinuePolling, executeGenerate, listProviders, registerProvider, testProviderConnection, unregisterProvider, } from './providers/index.js';
+import { preprocessRequestBody } from './upload/preprocess.js';
+export * from './generation/core.js';
+/**
+ * 创建默认含 100 个生成模型的兼容客户端。
+ *
+ * 这里仅负责装配旧的全量 catalog 与进程级 provider registry；所有目录、请求、取消和
+ * 生命周期行为都委托 `generation/core` 的唯一生成内核。
+ */
+export function createGenerationClient(config) {
+    const ownedProviderIds = registerClientProviders(config.providers ?? []);
+    try {
+        const customById = new Map((config.providers ?? []).map((provider) => [provider.id, provider]));
+        const providers = listProviders().map((providerId) => {
+            const custom = customById.get(providerId);
+            return {
+                id: providerId,
+                adapter: {
+                    execute: async (input) => await executeGenerate(providerId, input),
+                    continuePolling: async (input) => await executeContinuePolling(providerId, input),
+                },
+                preprocess: custom?.preprocess ?? (async (input) => await preprocessRequestBody(input.providerId, input.route, input.body, input.runtime, input.params, input.model.runtimeConstraints, input.requestId, input.signal)),
+                testConnection: custom?.testConnection ?? (async (runtime) => await testProviderConnection(providerId, runtime)),
+            };
+        });
+        return createGenerationClientCore({
+            runtime: config.runtime,
+            models: [...catalog, ...(config.models ?? [])],
+            providers,
+            onDispose: () => {
+                for (const providerId of ownedProviderIds)
+                    unregisterProvider(providerId);
+            },
+        });
+    }
+    catch (error) {
+        for (const providerId of ownedProviderIds)
+            unregisterProvider(providerId);
+        throw error;
+    }
+}
+function registerClientProviders(registrations) {
+    const registered = [];
+    try {
+        for (const registration of registrations) {
+            registerProvider(registration.id, registration.adapter);
+            registered.push(registration.id);
+        }
+        return registered;
+    }
+    catch (error) {
+        for (const providerId of registered)
+            unregisterProvider(providerId);
+        throw error;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @henjicc/ai-sdk 根入口。
+ *
+ * 各子路径入口保留模块边界，包根同时重新导出兼容公共内容。原因是 `tsconfig.electron.json` 的
+ * `moduleResolution: "node"`（TS 经典 Node10 解析）不识别 package.json 的 `exports`
+ * 字段，只认顶层 `main`/`types`，实测子路径导入会直接报
+ * `Cannot find module '@henjicc/ai-sdk/runtime'`（见任务 2.1 执行记录 /
+ * docs/task/模型SDK抽离/重要记录.md 记录 012）。因此 Electron 主进程代码
+ * （如 `electron/main/services/ai-runtime/sdk-runtime.ts`）必须统一从包根导入，
+ * 根入口需要把子路径的内容再导出一份。子路径导出（`./runtime` 等）仍然保留，
+ * 供支持 `exports` 条件解析的消费方（Vite/Rollup、`moduleResolution: "bundler"`/
+ * `"node16"`/`"nodenext"`）按需只导入需要的子集。
+ *
+ * 包名为 `@henjicc/ai-sdk`，从 0.2.8 起通过公共 npm registry 分发。
+ */
+export * from './client.js';
+export * from './generation.js';
+export * from './runtime/index.js';
+export * from './protocols/index.js';
+export * from './upload/index.js';
+export * from './providers/index.js';
+export * from './types/index.js';
+export * from './structured-output/index.js';
+export * from './catalog/index.js';
+export * from './pricing/index.js';
+export * from './llm/index.js';
+export * from './capabilities/index.js';
+export * from './discovery/index.js';

package/dist/index.js

@@ -0,0 +1,40 @@
+/**
+ * @henjicc/ai-sdk 根入口。
+ *
+ * 各子路径入口保留模块边界，包根同时重新导出兼容公共内容。原因是 `tsconfig.electron.json` 的
+ * `moduleResolution: "node"`（TS 经典 Node10 解析）不识别 package.json 的 `exports`
+ * 字段，只认顶层 `main`/`types`，实测子路径导入会直接报
+ * `Cannot find module '@henjicc/ai-sdk/runtime'`（见任务 2.1 执行记录 /
+ * docs/task/模型SDK抽离/重要记录.md 记录 012）。因此 Electron 主进程代码
+ * （如 `electron/main/services/ai-runtime/sdk-runtime.ts`）必须统一从包根导入，
+ * 根入口需要把子路径的内容再导出一份。子路径导出（`./runtime` 等）仍然保留，
+ * 供支持 `exports` 条件解析的消费方（Vite/Rollup、`moduleResolution: "bundler"`/
+ * `"node16"`/`"nodenext"`）按需只导入需要的子集。
+ *
+ * 包名为 `@henjicc/ai-sdk`，从 0.2.8 起通过公共 npm registry 分发。
+ */
+export * from './client.js';
+export * from './generation.js';
+export * from './runtime/index.js';
+// 任务 2.2 迁入：供应商无关的纯逻辑层（协议模板、媒体字段识别、PPIO 媒体判定、
+// 生成模型运行时契约类型）。同样重新导出到包根，理由与上面对 `./runtime` 的说明一致——
+// `tsconfig.electron.json` 的经典 Node 解析不识别 `exports` 子路径。
+export * from './protocols/index.js';
+export * from './upload/index.js';
+export * from './providers/index.js';
+export * from './types/index.js';
+export * from './structured-output/index.js';
+// 任务 3.1 迁入：模型目录（纯函数 defineModel + 运行时校验）。同样重新导出到包根，
+// 理由同上：`tsconfig.electron.json` 的经典 Node 解析不识别 `exports` 子路径。
+export * from './catalog/index.js';
+export * from './pricing/index.js';
+// 任务 4.1 迁入：LLM（openai-compatible 协议）供应商无关的纯逻辑层——协议差异、思考参数、
+// 模型能力目录、供应商预设、默认值、模型步契约、共享类型。理由同上：`tsconfig.electron.json`
+// 的经典 Node 解析不识别 `exports` 子路径，Electron 主进程必须能从包根拿到这些导出。
+// 任务 4.2 追加：LLM 执行层——原生 SSE 流式聊天路径（`chatTypes`/`streaming`/`chat`/
+// `requestContract`/`discovery`）与 Vercel AI SDK 模型步路径（`llm/sdk/`）。均已在
+// `./llm/index.ts` 内部重新导出，这里不需要再单独加一行。
+export * from './llm/index.js';
+// 开放能力模块协议与生成/LLM 执行内核解耦；ASR/OCR 等新种类无需改动根 client switch。
+export * from './capabilities/index.js';
+export * from './discovery/index.js';

package/dist/llm/bigmodel/index.d.ts

@@ -0,0 +1,3 @@
+export * from './profiles.js';
+export * from './preset.js';
+export { resolveLlmEndpointIdentity } from '../endpointProfiles.js';

package/dist/llm/bigmodel/index.js

@@ -0,0 +1,3 @@
+export * from './profiles.js';
+export * from './preset.js';
+export { resolveLlmEndpointIdentity } from '../endpointProfiles.js';

package/dist/llm/bigmodel/preset.d.ts

@@ -0,0 +1,11 @@
+import { resolveLlmEndpointIdentity } from '../endpointProfiles.js';
+import type { LlmModelConfig, LlmProviderConfig } from '../types.js';
+export interface CreateBigmodelProviderOptions {
+    endpointProfile?: 'cn' | 'global';
+    /** 宿主配置实例 id；默认 cn=bigmodel、global=bigmodel-global。 */
+    providerId?: string;
+    lifecycle?: 'builtin' | 'user';
+}
+export declare function createBigmodelProvider(options?: CreateBigmodelProviderOptions): LlmProviderConfig;
+export declare function createBigmodelModels(provider: LlmProviderConfig): LlmModelConfig[];
+export declare function resolveBigmodelIdentity(input: LlmProviderConfig): ReturnType<typeof resolveLlmEndpointIdentity>;

package/dist/llm/bigmodel/preset.js

@@ -0,0 +1,58 @@
+import { createLlmCapabilitiesForModel } from '../defaults.js';
+import { resolveLlmEndpointIdentity } from '../endpointProfiles.js';
+import { BIGMODEL_ENDPOINT_PROFILE_FAMILY, BIGMODEL_PROVIDER_FAMILY_ID, } from './profiles.js';
+export function createBigmodelProvider(options = {}) {
+    const profileId = options.endpointProfile ?? 'cn';
+    const providerId = options.providerId ?? (profileId === 'cn' ? 'bigmodel' : 'bigmodel-global');
+    const identity = resolveLlmEndpointIdentity({
+        providerId,
+        providerFamilyId: BIGMODEL_PROVIDER_FAMILY_ID,
+        endpointProfile: profileId,
+    });
+    const profile = BIGMODEL_ENDPOINT_PROFILE_FAMILY.profiles.find(item => item.id === profileId);
+    if (!profile)
+        throw new Error(`[llm_endpoint_profile_unknown] bigmodel endpoint profile "${profileId}" is unavailable`);
+    return {
+        providerId: identity.providerId,
+        providerFamilyId: identity.providerFamilyId,
+        endpointProfile: identity.endpointProfile,
+        credentialId: identity.credentialId,
+        setup: {
+            kind: 'preset',
+            presetId: BIGMODEL_PROVIDER_FAMILY_ID,
+            lifecycle: options.lifecycle ?? 'user',
+        },
+        displayName: profile.displayName,
+        adapter: 'openai',
+        apiProtocol: 'openai-compatible',
+        baseUrl: identity.baseUrl,
+        reasoning: { enabled: true, effort: 'max' },
+        reasoningConfigurable: true,
+        enabled: true,
+    };
+}
+export function createBigmodelModels(provider) {
+    const identity = resolveLlmEndpointIdentity(provider);
+    const profile = BIGMODEL_ENDPOINT_PROFILE_FAMILY.profiles.find(item => item.id === identity.endpointProfile);
+    if (!profile)
+        throw new Error('[llm_endpoint_profile_unknown] resolved BigModel endpoint profile is unavailable');
+    return profile.modelIds.map(modelId => ({
+        providerId: identity.providerId,
+        providerFamilyId: identity.providerFamilyId,
+        endpointProfile: identity.endpointProfile,
+        credentialId: identity.credentialId,
+        modelId,
+        displayName: modelId === 'glm-5.3-flash' ? 'GLM-5.3-Flash' : modelId,
+        adapter: provider.adapter,
+        apiProtocol: identity.endpointProfile === 'cn' && modelId === 'glm-5.3'
+            ? 'openai-responses'
+            : 'openai-compatible',
+        baseUrl: identity.baseUrl,
+        capabilities: createLlmCapabilitiesForModel(modelId),
+        catalogId: modelId,
+        enabled: true,
+    }));
+}
+export function resolveBigmodelIdentity(input) {
+    return resolveLlmEndpointIdentity(input);
+}

package/dist/llm/bigmodel/profiles.d.ts

@@ -0,0 +1,21 @@
+import type { LlmEndpointProfileFamily } from '../endpointProfiles.js';
+export declare const BIGMODEL_PROVIDER_FAMILY_ID = "bigmodel";
+export declare const BIGMODEL_CN_PROFILE_ID = "cn";
+export declare const BIGMODEL_GLOBAL_PROFILE_ID = "global";
+export declare const BIGMODEL_CN_CREDENTIAL_ID = "bigmodel";
+export declare const BIGMODEL_GLOBAL_CREDENTIAL_ID = "bigmodel-global";
+export interface BigmodelTokenPricing {
+    currency: 'CNY' | 'USD';
+    inputPerMillionTokens: number;
+    outputPerMillionTokens: number;
+    cacheReadPerMillionTokens: number;
+    promotion?: {
+        inputPerMillionTokens: number;
+        outputPerMillionTokens: number;
+        cacheReadPerMillionTokens: number;
+        endsAt?: string;
+        observedAt: string;
+    };
+}
+export declare const BIGMODEL_ENDPOINT_PROFILE_FAMILY: LlmEndpointProfileFamily;
+export declare const BIGMODEL_GLM_5_3_FLASH_PRICING: Readonly<Record<'cn' | 'global', BigmodelTokenPricing>>;

package/dist/llm/bigmodel/profiles.js

@@ -0,0 +1,65 @@
+import { findProviderMetadata } from '../../providers/metadata.js';
+export const BIGMODEL_PROVIDER_FAMILY_ID = 'bigmodel';
+export const BIGMODEL_CN_PROFILE_ID = 'cn';
+export const BIGMODEL_GLOBAL_PROFILE_ID = 'global';
+export const BIGMODEL_CN_CREDENTIAL_ID = 'bigmodel';
+export const BIGMODEL_GLOBAL_CREDENTIAL_ID = 'bigmodel-global';
+const BIGMODEL_CN_METADATA = findProviderMetadata(BIGMODEL_PROVIDER_FAMILY_ID);
+const BIGMODEL_GLOBAL_METADATA = findProviderMetadata(BIGMODEL_PROVIDER_FAMILY_ID, { endpointProfile: 'global' });
+if (!BIGMODEL_CN_METADATA || !BIGMODEL_GLOBAL_METADATA) {
+    throw new Error('[provider_metadata_missing] BigModel endpoint metadata is not registered');
+}
+export const BIGMODEL_ENDPOINT_PROFILE_FAMILY = {
+    providerFamilyId: BIGMODEL_PROVIDER_FAMILY_ID,
+    defaultProfile: BIGMODEL_CN_PROFILE_ID,
+    profiles: [
+        {
+            id: BIGMODEL_CN_PROFILE_ID,
+            displayName: '智谱 GLM（中国大陆）',
+            baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+            protocolBaseUrls: { 'openai-responses': 'https://open.bigmodel.cn/api/v1' },
+            websiteUrl: BIGMODEL_CN_METADATA.websiteUrl,
+            apiKeyUrl: BIGMODEL_CN_METADATA.apiKeyUrl,
+            defaultCredentialId: BIGMODEL_CN_CREDENTIAL_ID,
+            modelIds: ['glm-5.3', 'glm-5v-turbo', 'glm-5.3-flash'],
+            docs: 'docs/llm-adaptation/供应商/智谱GLM.md',
+        },
+        {
+            id: BIGMODEL_GLOBAL_PROFILE_ID,
+            displayName: 'Z.AI GLM（Global）',
+            baseUrl: 'https://api.z.ai/api/paas/v4',
+            websiteUrl: BIGMODEL_GLOBAL_METADATA.websiteUrl,
+            apiKeyUrl: BIGMODEL_GLOBAL_METADATA.apiKeyUrl,
+            defaultCredentialId: BIGMODEL_GLOBAL_CREDENTIAL_ID,
+            modelIds: ['glm-5.3-flash'],
+            docs: 'docs/model-adaptation/GLM-5.3-Flash/GLM-5.3-Flash_智谱.md',
+        },
+    ],
+};
+export const BIGMODEL_GLM_5_3_FLASH_PRICING = {
+    cn: {
+        currency: 'CNY',
+        inputPerMillionTokens: 0.8,
+        outputPerMillionTokens: 2.8,
+        cacheReadPerMillionTokens: 0.23,
+        promotion: {
+            inputPerMillionTokens: 0.4,
+            outputPerMillionTokens: 1.4,
+            cacheReadPerMillionTokens: 0.115,
+            observedAt: '2026-08-28',
+        },
+    },
+    global: {
+        currency: 'USD',
+        inputPerMillionTokens: 0.15,
+        outputPerMillionTokens: 0.5,
+        cacheReadPerMillionTokens: 0.03,
+        promotion: {
+            inputPerMillionTokens: 0.075,
+            outputPerMillionTokens: 0.25,
+            cacheReadPerMillionTokens: 0.015,
+            endsAt: '2026-09-09T16:00:00.000Z',
+            observedAt: '2026-08-28',
+        },
+    },
+};