@henjicc/ai-sdk 0.2.8

package/dist/client.js

@@ -0,0 +1,38 @@
+import { createGenerationClient, } from './generation.js';
+import { createModularGenerationClient, } from './generation/core.js';
+import { resolveLlmTaskId, runLlmChatStream, } from './llm/chat.js';
+import { runModelStep } from './llm/sdk/runtime.js';
+import { resolveRuntimeContext } from './runtime/index.js';
+/**
+ * 创建共享一个 RuntimeContext 的完整 SDK 客户端。生成能力直接组合
+ * {@link createGenerationClient} 的唯一内核；根入口只追加 LLM 能力。
+ */
+export function createAIClient(config) {
+    const generation = config.generation?.mode === 'modular'
+        ? createModularGenerationClient({
+            runtime: config.runtime,
+            models: config.models,
+            providers: config.providers,
+            packs: config.generation.packs,
+        })
+        : createGenerationClient(config);
+    const runtime = resolveRuntimeContext(config.runtime);
+    const ensureActive = () => {
+        // 复用生成内核的 disposal 守卫，不维护第二份生命周期状态。
+        generation.catalog.list();
+    };
+    return {
+        ...generation,
+        chat: {
+            async stream(request, emit, hooks = {}) {
+                ensureActive();
+                const taskId = resolveLlmTaskId(request);
+                return await runLlmChatStream(request, taskId, emit, runtime, hooks);
+            },
+            async modelStep(input, emit) {
+                ensureActive();
+                return await runModelStep(input, emit, runtime);
+            },
+        },
+    };
+}

package/dist/discovery/index.d.ts

@@ -0,0 +1,77 @@
+import type { CapabilityDescriptor, CapabilityModule, CapabilityRealtimeModule } from '../capabilities/index.js';
+import type { GenerationPack } from '../generation/core.js';
+import type { LlmModelCatalogEntry } from '../llm/modelCatalog.js';
+import type { LlmModelConfig } from '../llm/types.js';
+import type { LlmModuleDescriptor } from '../llm/modules/types.js';
+import type { ModelRuntimeDefinition, ModelType } from '../types/model.js';
+type ExtensibleString = string & Record<never, never>;
+export type StandardModelOperation = 'image-generation' | 'text-to-image' | 'image-edit' | 'video-generation' | 'text-to-video' | 'image-to-video' | 'reference-to-video' | 'video-edit' | 'audio-generation' | 'chat' | 'speech-recognition' | 'speech-to-text' | 'translation' | 'text-translation' | 'ocr';
+export type ModelOperation = StandardModelOperation | ExtensibleString;
+export type ModelContentKind = 'text' | 'structured-data' | 'image' | 'video' | 'audio' | 'pdf' | ExtensibleString;
+export interface ModelCapabilityProfile {
+    id: string;
+    providerIds: readonly string[];
+    outputModalities: readonly ModelType[];
+    operations: readonly ModelOperation[];
+    acceptedInputContentKinds: readonly ModelContentKind[];
+    outputContentKinds: readonly ModelContentKind[];
+    features: readonly string[];
+    tags: readonly string[];
+}
+export interface CapabilityCriterion<T extends string> {
+    anyOf?: readonly T[];
+    allOf?: readonly T[];
+}
+export interface ModelCapabilityQuery {
+    /** 默认各维度 AND；`any` 表示任一已填写维度命中。 */
+    mode?: 'all' | 'any';
+    providerIds?: string | CapabilityCriterion<string>;
+    outputModalities?: ModelType | CapabilityCriterion<ModelType>;
+    operations?: ModelOperation | CapabilityCriterion<ModelOperation>;
+    acceptedInputContentKinds?: ModelContentKind | CapabilityCriterion<ModelContentKind>;
+    outputContentKinds?: ModelContentKind | CapabilityCriterion<ModelContentKind>;
+    features?: string | CapabilityCriterion<string>;
+    tags?: string | CapabilityCriterion<string>;
+}
+export type CapabilityDiscoveryItem = {
+    sourceKind: 'generation-model';
+    id: string;
+    profile: ModelCapabilityProfile;
+    source: ModelRuntimeDefinition;
+} | {
+    sourceKind: 'llm-model';
+    id: string;
+    profile: ModelCapabilityProfile;
+    source: LlmModelCatalogEntry | LlmModelConfig;
+} | {
+    sourceKind: 'llm-module';
+    id: string;
+    profile: ModelCapabilityProfile;
+    source: LlmModuleDescriptor;
+} | {
+    sourceKind: 'extension';
+    id: string;
+    profile: ModelCapabilityProfile;
+    source: CapabilityDescriptor;
+};
+export interface CreateCapabilityDiscoveryInput {
+    generationPacks?: readonly GenerationPack[];
+    generationModels?: readonly ModelRuntimeDefinition[];
+    llmEntries?: readonly LlmModelCatalogEntry[];
+    llmModels?: readonly LlmModelConfig[];
+    llmModules?: readonly LlmModuleDescriptor[];
+    extensions?: readonly (CapabilityDescriptor | CapabilityModule<unknown, unknown, unknown> | CapabilityRealtimeModule<unknown, unknown, unknown, unknown>)[];
+}
+export interface ModelCapabilityDiscovery {
+    list(): readonly CapabilityDiscoveryItem[];
+    search(query: ModelCapabilityQuery): readonly CapabilityDiscoveryItem[];
+}
+/** 只从宿主已导入的候选 pack/module 建立发现索引；不会隐式导入默认 catalog。 */
+export declare function createModelCapabilityDiscovery(input: CreateCapabilityDiscoveryInput): ModelCapabilityDiscovery;
+export declare function profileGenerationModel(model: ModelRuntimeDefinition): ModelCapabilityProfile;
+export declare function profileLlmCatalogEntry(entry: LlmModelCatalogEntry): ModelCapabilityProfile;
+export declare function profileLlmModel(model: LlmModelConfig): ModelCapabilityProfile;
+export declare function profileLlmModule(module: LlmModuleDescriptor): ModelCapabilityProfile;
+export declare function profileCapabilityDescriptor(descriptor: CapabilityDescriptor): ModelCapabilityProfile;
+export declare function matchesModelCapabilityProfile(profile: ModelCapabilityProfile, query: ModelCapabilityQuery): boolean;
+export {};

package/dist/discovery/index.js

@@ -0,0 +1,238 @@
+import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+import { normalizeCapabilityStableId, validateCapabilityDescriptor, } from '../capabilities/validation.js';
+import { validateLlmModuleDescriptor } from '../llm/modules/validation.js';
+/** 只从宿主已导入的候选 pack/module 建立发现索引；不会隐式导入默认 catalog。 */
+export function createModelCapabilityDiscovery(input) {
+    const items = [];
+    const itemsById = new Map();
+    const add = (item) => {
+        normalizeCapabilityStableId(item.id, 'invalid_capability_discovery_id', 'Capability discovery id');
+        const existing = itemsById.get(item.id);
+        if (existing) {
+            throw new AiRuntimeError('capability_discovery_id_conflict', `Discovery id "${item.id}" from ${describeDiscoveryItem(item)} conflicts with ` +
+                `${describeDiscoveryItem(existing)}`);
+        }
+        itemsById.set(item.id, item);
+        items.push(item);
+    };
+    const generation = dedupeGenerationModels([
+        ...(input.generationModels ?? []),
+        ...(input.generationPacks ?? []).flatMap((pack) => pack.models),
+    ]);
+    for (const model of generation) {
+        add({ sourceKind: 'generation-model', id: model.meta.id, profile: profileGenerationModel(model), source: model });
+    }
+    for (const entry of input.llmEntries ?? []) {
+        add({ sourceKind: 'llm-model', id: entry.id, profile: profileLlmCatalogEntry(entry), source: entry });
+    }
+    for (const model of input.llmModels ?? []) {
+        const providerId = normalizeCapabilityStableId(model.providerId, 'invalid_capability_provider_id', 'LLM provider id');
+        const modelId = normalizeCapabilityStableId(model.modelId, 'invalid_capability_model_id', 'LLM model id');
+        const id = `${providerId}:${modelId}`;
+        add({ sourceKind: 'llm-model', id, profile: profileLlmModel(model), source: model });
+    }
+    for (const module of input.llmModules ?? []) {
+        validateLlmModuleDescriptor(module);
+        const id = `${module.providerId}:${module.modelId}`;
+        add({ sourceKind: 'llm-module', id, profile: profileLlmModule(module), source: module });
+    }
+    for (const extension of input.extensions ?? []) {
+        const descriptor = 'descriptor' in extension ? extension.descriptor : extension;
+        validateCapabilityDescriptor(descriptor);
+        add({ sourceKind: 'extension', id: descriptor.id, profile: profileCapabilityDescriptor(descriptor), source: descriptor });
+    }
+    return {
+        list: () => items,
+        search: (query) => items.filter((item) => matchesModelCapabilityProfile(item.profile, query)),
+    };
+}
+export function profileGenerationModel(model) {
+    const tags = [...new Set(model.meta.tags ?? [])];
+    const operations = deriveGenerationOperations(model.meta.type, tags);
+    const inputs = new Set();
+    if (model.acceptsPrompt !== false)
+        inputs.add('text');
+    collectParamInputs(model, inputs);
+    collectLimitInputs(model.inputLimits, inputs);
+    for (const field of model.runtimeConstraints?.mediaFields ?? [])
+        inputs.add(field.kind);
+    const output = model.meta.type;
+    return {
+        id: model.meta.id,
+        providerIds: [model.meta.provider],
+        outputModalities: [model.meta.type],
+        operations,
+        acceptedInputContentKinds: [...inputs],
+        outputContentKinds: [output],
+        features: tags.filter((tag) => !tag.startsWith('provider-') && !operations.includes(tag)),
+        tags,
+    };
+}
+export function profileLlmCatalogEntry(entry) {
+    const inputs = ['text'];
+    if (entry.input.image)
+        inputs.push('image');
+    if (entry.input.video)
+        inputs.push('video');
+    if (entry.input.audio)
+        inputs.push('audio');
+    const features = llmFeatures(entry.toolCall, entry.parallelTools, entry.reasoning, entry.structuredOutputMode);
+    return llmProfile(entry.id, [entry.vendor.toLowerCase()], inputs, features, entry.structuredOutputMode);
+}
+export function profileLlmModel(model) {
+    const inputs = ['text'];
+    if (model.capabilities.image)
+        inputs.push('image');
+    if (model.capabilities.video)
+        inputs.push('video');
+    if (model.capabilities.audio)
+        inputs.push('audio');
+    const features = llmFeatures(model.capabilities.toolCall, model.capabilities.parallelTools, model.capabilities.reasoning, model.capabilities.structuredOutputMode);
+    return llmProfile(`${model.providerId}:${model.modelId}`, [model.providerId], inputs, features, model.capabilities.structuredOutputMode);
+}
+export function profileLlmModule(module) {
+    const profile = profileLlmModel({
+        providerId: module.providerId,
+        modelId: module.modelId,
+        displayName: module.displayName ?? module.modelId,
+        adapter: 'external-module',
+        capabilities: module.capabilities,
+        enabled: true,
+    });
+    return { ...profile, tags: module.tags ? [...module.tags] : [] };
+}
+export function profileCapabilityDescriptor(descriptor) {
+    return {
+        id: descriptor.id,
+        providerIds: descriptor.providerIds ? [...descriptor.providerIds] : [],
+        outputModalities: descriptor.contract.output.map((value) => value.kind),
+        operations: descriptor.operations?.length ? [...descriptor.operations] : [descriptor.kind],
+        acceptedInputContentKinds: descriptor.contract.input.map((value) => value.kind),
+        outputContentKinds: descriptor.contract.output.map((value) => value.kind),
+        features: descriptor.features ? [...descriptor.features] : [],
+        tags: descriptor.tags ? [...descriptor.tags] : [],
+    };
+}
+export function matchesModelCapabilityProfile(profile, query) {
+    const checks = [
+        criterionMatches(profile.providerIds, query.providerIds),
+        criterionMatches(profile.outputModalities, query.outputModalities),
+        criterionMatches(profile.operations, query.operations),
+        criterionMatches(profile.acceptedInputContentKinds, query.acceptedInputContentKinds),
+        criterionMatches(profile.outputContentKinds, query.outputContentKinds),
+        criterionMatches(profile.features, query.features),
+        criterionMatches(profile.tags, query.tags),
+    ].filter((value) => value !== undefined);
+    if (checks.length === 0)
+        return true;
+    return query.mode === 'any' ? checks.some(Boolean) : checks.every(Boolean);
+}
+function criterionMatches(values, criterion) {
+    if (criterion === undefined)
+        return undefined;
+    if (typeof criterion === 'string')
+        return values.includes(criterion);
+    const any = criterion.anyOf ?? [];
+    const all = criterion.allOf ?? [];
+    return (any.length === 0 || any.some((value) => values.includes(value))) &&
+        all.every((value) => values.includes(value));
+}
+function deriveGenerationOperations(type, tags) {
+    const operations = new Set();
+    if (type === 'image') {
+        operations.add('image-generation');
+        if (tags.includes('text-to-image'))
+            operations.add('text-to-image');
+        if (tags.some((tag) => ['image-to-image', 'supports-image-editing', 'image-edit'].includes(tag)))
+            operations.add('image-edit');
+    }
+    else if (type === 'video') {
+        operations.add('video-generation');
+        if (tags.includes('text-to-video'))
+            operations.add('text-to-video');
+        if (tags.some((tag) => ['image-to-video', 'start-end-frame'].includes(tag)))
+            operations.add('image-to-video');
+        if (tags.some((tag) => ['reference-mode', 'video-reference', 'multi-image-reference'].includes(tag)))
+            operations.add('reference-to-video');
+        if (tags.some((tag) => ['supports-video-editing', 'video-to-video', 'video-extension'].includes(tag)))
+            operations.add('video-edit');
+    }
+    else if (type === 'audio') {
+        operations.add('audio-generation');
+    }
+    else {
+        operations.add(`${type}-generation`);
+    }
+    return [...operations];
+}
+function collectParamInputs(model, target) {
+    const visit = (params) => {
+        for (const param of params) {
+            if (param.type === 'image-upload')
+                target.add('image');
+            else if (param.type === 'video-upload')
+                target.add('video');
+            else if (param.type === 'file-upload')
+                target.add('pdf');
+            else if (param.type === 'panel')
+                visit(param.children);
+        }
+    };
+    visit(model.params);
+}
+function collectLimitInputs(limits, target) {
+    if (!limits)
+        return;
+    let value;
+    try {
+        value = typeof limits === 'function' ? limits({}) : limits;
+    }
+    catch {
+        return;
+    }
+    if (value.images && value.images.max !== 0)
+        target.add('image');
+    if (value.videos && value.videos.max !== 0)
+        target.add('video');
+    if (value.audios && value.audios.max !== 0)
+        target.add('audio');
+    for (const rule of value.rules ?? []) {
+        if (rule.images && rule.images.max !== 0)
+            target.add('image');
+        if (rule.videos && rule.videos.max !== 0)
+            target.add('video');
+        if (rule.audios && rule.audios.max !== 0)
+            target.add('audio');
+    }
+}
+function llmFeatures(toolCall, parallelTools, reasoning, structuredOutputMode) {
+    return [
+        ...(toolCall ? ['tool-call'] : []),
+        ...(parallelTools ? ['parallel-tools'] : []),
+        ...(reasoning ? ['reasoning'] : []),
+        ...(structuredOutputMode !== 'none' ? ['structured-output'] : []),
+    ];
+}
+function llmProfile(id, providerIds, inputs, features, structuredOutputMode) {
+    return {
+        id,
+        providerIds,
+        outputModalities: ['text'],
+        operations: ['chat'],
+        acceptedInputContentKinds: inputs,
+        outputContentKinds: ['text', ...(structuredOutputMode !== 'none' ? ['structured-data'] : [])],
+        features,
+        tags: [],
+    };
+}
+function dedupeGenerationModels(models) {
+    return [...new Map(models.map((model) => [model.meta.id, model])).values()];
+}
+function describeDiscoveryItem(item) {
+    if (item.sourceKind === 'llm-module') {
+        return `${item.source.source.kind} source "${item.source.source.namespace}" LLM module`;
+    }
+    if (item.sourceKind !== 'extension')
+        return `${item.sourceKind}`;
+    return `${item.source.source.kind} source "${item.source.source.namespace}"`;
+}

package/dist/generation/core.d.ts

@@ -0,0 +1,96 @@
+import type { ProviderAdapter } from '../providers/types.js';
+import { type RuntimeContext } from '../runtime/RuntimeContext.js';
+import { type TaskNamespace } from '../runtime/task-registry.js';
+import type { ModelRuntimeDefinition, ModelTag, ModelType, ProviderId, RuntimeParamDef } from '../types/model.js';
+import type { AiContinuePollingRequestDto, AiGenerateRequestDto, JsonObject, JsonValue, ProviderConnectionTestResultDto, ProviderExecutionResult } from '../types/runtime.js';
+export interface GenerationPreprocessInput {
+    providerId: ProviderId;
+    route: string;
+    body: JsonValue;
+    runtime: RuntimeContext;
+    params: JsonObject;
+    model: ModelRuntimeDefinition;
+    requestId: string;
+    signal: AbortSignal;
+}
+export type GenerationRequestPreprocessor = (input: GenerationPreprocessInput) => Promise<JsonValue>;
+export interface GenerationClientProviderRegistration {
+    id: ProviderId;
+    adapter: ProviderAdapter;
+    preprocess?: GenerationRequestPreprocessor;
+    testConnection?: (runtime: RuntimeContext) => Promise<ProviderConnectionTestResultDto>;
+}
+export interface GenerationPack {
+    readonly models: readonly ModelRuntimeDefinition[];
+    readonly providers: readonly GenerationClientProviderRegistration[];
+}
+export interface CreateModularGenerationClientConfig {
+    runtime: RuntimeContext;
+    models?: readonly ModelRuntimeDefinition[];
+    providers?: readonly GenerationClientProviderRegistration[];
+    packs?: readonly GenerationPack[];
+}
+export interface GenerationClientResult {
+    status: ProviderExecutionResult['status'];
+    url: string;
+    taskId?: string;
+    metadata: JsonValue;
+    structuredOutput?: ProviderExecutionResult['structuredOutput'];
+}
+export interface GenerationClientRequestInfo {
+    requestId: string;
+    requestedModelId: string;
+    providerId: ProviderId;
+    route: string;
+    method: string;
+    requestBody: JsonValue;
+}
+export interface GenerationClientCompletedInfo extends GenerationClientRequestInfo {
+    result: GenerationClientResult;
+}
+export interface GenerationClientHooks {
+    onRequestBuilt?: (info: GenerationClientRequestInfo) => void;
+    onCompleted?: (info: GenerationClientCompletedInfo) => void;
+}
+export interface GenerationClientContinuePollingRequest extends AiContinuePollingRequestDto {
+    /** 宿主需要稳定关联日志或取消时可显式传入；不属于痕迹AI IPC DTO。 */
+    requestId?: string;
+}
+export interface GenerationClientCancelRequest {
+    namespace: TaskNamespace;
+    taskId: string;
+}
+export interface GenerationClientCatalog {
+    get(modelId: string): ModelRuntimeDefinition | undefined;
+    list(): readonly ModelRuntimeDefinition[];
+    listByType(type: ModelType): readonly ModelRuntimeDefinition[];
+    listByProvider(providerId: ProviderId): readonly ModelRuntimeDefinition[];
+    listByTag(tag: ModelTag): readonly ModelRuntimeDefinition[];
+    getDefaultValues(modelId: string): JsonObject;
+    getParams(modelId: string): readonly RuntimeParamDef[];
+    estimatePrice(modelId: string, params?: JsonObject): number;
+    resolveParams(modelId: string, params?: JsonObject): JsonObject;
+}
+export interface GenerationClientProviders {
+    list(): ProviderId[];
+    testConnection(providerId: ProviderId): Promise<ProviderConnectionTestResultDto>;
+}
+export interface GenerationClient {
+    generate(request: AiGenerateRequestDto, hooks?: GenerationClientHooks): Promise<GenerationClientResult>;
+    continuePolling(request: GenerationClientContinuePollingRequest, hooks?: GenerationClientHooks): Promise<GenerationClientResult>;
+    cancel(request: GenerationClientCancelRequest): void;
+    catalog: GenerationClientCatalog;
+    providers: GenerationClientProviders;
+    dispose(): void;
+}
+/** 创建不含任何内置模型或供应商的生成客户端。 */
+export declare function createModularGenerationClient(config: CreateModularGenerationClientConfig): GenerationClient;
+interface CreateGenerationClientCoreConfig {
+    runtime: RuntimeContext;
+    models: readonly ModelRuntimeDefinition[];
+    providers: readonly GenerationClientProviderRegistration[];
+    onDispose?: () => void;
+}
+/** @internal 默认全量入口也委托这一份生成内核。 */
+export declare function createGenerationClientCore(config: CreateGenerationClientCoreConfig): GenerationClient;
+export {};