@henjicc/ai-sdk 0.2.8

package/dist/llm/streaming.js

@@ -0,0 +1,330 @@
+import { fetchProvider } from '../providers/provider-fetch.js';
+import { applyProviderRequestBodyQuirks, resolveProviderExtraAuthHeaders, } from './providerProtocolCore.js';
+import { applyProviderReasoningRequestBody } from './providerReasoningRequest.js';
+import { createUtf8StreamDecoder } from './utf8-stream-decoder.js';
+import { resolveLlmEndpointIdentity } from './endpointProfiles.js';
+export function resolvePpioChatEndpoint(baseUrl) {
+    const normalized = normalizeBaseUrl(baseUrl, 'https://api.ppio.com/openai');
+    return /\/v\d+$/.test(normalized)
+        ? `${normalized}/chat/completions`
+        : `${normalized}/v1/chat/completions`;
+}
+export function resolveOpenAiCompatibleEndpoint(request) {
+    const identity = resolveLlmEndpointIdentity(request);
+    const providerId = identity.providerFamilyId;
+    const adapter = request.adapter?.trim().toLowerCase();
+    const fallbackBaseUrl = providerId === 'openai' || adapter === 'openai'
+        ? 'https://api.openai.com'
+        : (providerId === 'deepseek' || adapter === 'deepseek' ? 'https://api.deepseek.com' : undefined);
+    if (!identity.baseUrl && !fallbackBaseUrl) {
+        throw new Error(`LLM provider "${request.providerId}" requires baseUrl.`);
+    }
+    const normalized = normalizeBaseUrl(identity.baseUrl, fallbackBaseUrl);
+    return /\/v\d+$/.test(normalized)
+        ? `${normalized}/chat/completions`
+        : `${normalized}/v1/chat/completions`;
+}
+export function buildOpenAiCompatiblePayload(request) {
+    const policy = request.policy ?? {};
+    const payload = {
+        model: request.modelId,
+        messages: request.messages.map(serializeMessage),
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+    const maxTokens = readNumber(policy.max_tokens ?? policy.maxTokens);
+    payload.max_tokens = maxTokens ?? 4096;
+    if (request.tools !== undefined) {
+        payload.tools = request.tools;
+    }
+    /*
+     * 思考参数按供应商翻译，与 SDK 模型步骤共用同一份映射。
+     *
+     * 旧实现只认 deepseek，且发的是 `reasoning: true` 而不是官方要求的 `thinking` + `reasoning_effort`：
+     * 画布文本处理和提示词优化的「思考模式」下拉对任何供应商都不生效。
+     * 用模型能力表兜一层，没标"支持思考"的模型仍然一个字段都不发。
+     */
+    const identity = resolveLlmEndpointIdentity(request);
+    const reasoningCapable = request.capabilities?.reasoning === true;
+    const withReasoning = reasoningCapable
+        ? applyProviderReasoningRequestBody(identity.providerFamilyId, request.adapter, payload, request.reasoning)
+        : payload;
+    return applyProviderRequestBodyQuirks(identity.providerFamilyId, withReasoning);
+}
+export async function streamOpenAiCompatibleChat(options) {
+    const identity = resolveLlmEndpointIdentity(options.request);
+    const response = await fetchProvider(identity.providerFamilyId, options.endpoint, {
+        method: 'POST',
+        headers: {
+            Accept: 'text/event-stream',
+            Authorization: `Bearer ${options.apiKey}`,
+            ...resolveProviderExtraAuthHeaders(identity.providerFamilyId, options.apiKey),
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(buildOpenAiCompatiblePayload(options.request)),
+        signal: options.signal,
+    }, {
+        transport: options.transport,
+        retryPreconnectOnce: true,
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        throw Object.assign(new Error(`LLM HTTP ${response.status}`), {
+            statusCode: response.status,
+            responseBody,
+            responseHeaders: response.headers,
+        });
+    }
+    if (!response.body) {
+        throw new Error('LLM streaming response body is empty');
+    }
+    return await readSseStream(response.body, options.emit);
+}
+export function serializeMessage(message) {
+    const serialized = { role: message.role };
+    if (message.name) {
+        serialized.name = message.name;
+    }
+    if (Array.isArray(message.content)) {
+        serialized.content = message.content.map(serializeContentPart);
+    }
+    else if (message.content !== undefined) {
+        serialized.content = message.content;
+    }
+    else {
+        serialized.content = null;
+    }
+    return serialized;
+}
+function serializeContentPart(part) {
+    const next = {};
+    for (const [key, value] of Object.entries(part)) {
+        if (value === undefined)
+            continue;
+        if (key === 'fileId' || (key === 'file' && isRecord(value) && ('fileId' in value || 'file_id' in value))) {
+            throw new Error('[unsupported_file_reference] LLM SDK does not create or accept provider file_id; use host-supplied fileUrl/fileData');
+        }
+        if (key === 'imageUrl') {
+            next.image_url = value;
+        }
+        else if (key === 'videoUrl') {
+            next.video_url = value;
+        }
+        else if (key === 'inputAudio') {
+            next.input_audio = value;
+        }
+        else if (key === 'file' && isRecord(value)) {
+            const referenceCount = Number(typeof value.fileUrl === 'string' && value.fileUrl.length > 0)
+                + Number(typeof value.fileData === 'string' && value.fileData.length > 0);
+            if (referenceCount !== 1) {
+                throw new Error('[invalid_file_reference] LLM file content requires exactly one of fileUrl or fileData');
+            }
+            const file = {};
+            for (const [fileKey, fileValue] of Object.entries(value)) {
+                if (fileValue === undefined)
+                    continue;
+                if (fileKey === 'fileUrl')
+                    file.file_url = fileValue;
+                else if (fileKey === 'fileData')
+                    file.file_data = fileValue;
+                else
+                    file[fileKey] = fileValue;
+            }
+            next.file = file;
+        }
+        else {
+            next[key] = value;
+        }
+    }
+    return next;
+}
+async function readSseStream(body, emit) {
+    const reader = body.getReader();
+    const decoder = createUtf8StreamDecoder();
+    let pending = '';
+    let output = '';
+    let reasoningOutput = '';
+    let usage = null;
+    let finishReason = null;
+    const toolCalls = new Map();
+    let streamDone = false;
+    while (!streamDone) {
+        const result = await reader.read();
+        if (result.done) {
+            streamDone = true;
+            continue;
+        }
+        pending += decoder.decode(result.value, { stream: true });
+        const parsed = drainSseEvents(pending);
+        pending = parsed.remaining;
+        for (const event of parsed.events) {
+            const chunk = parseSseData(event);
+            if (chunk.done) {
+                return { output, reasoningOutput, usage, finishReason, toolCalls: [...toolCalls.values()] };
+            }
+            usage = chunk.usage ?? usage;
+            finishReason = chunk.finishReason ?? finishReason;
+            mergeToolCallDeltas(toolCalls, chunk.toolCalls);
+            if (chunk.reasoning) {
+                reasoningOutput += chunk.reasoning;
+                emit({ type: 'ReasoningToken', data: chunk.reasoning });
+            }
+            if (chunk.content) {
+                output += chunk.content;
+                emit({ type: 'Token', data: chunk.content });
+            }
+        }
+    }
+    const flushed = decoder.decode();
+    if (flushed) {
+        pending += flushed;
+    }
+    const parsed = drainSseEvents(`${pending}\n\n`);
+    for (const event of parsed.events) {
+        const chunk = parseSseData(event);
+        usage = chunk.usage ?? usage;
+        finishReason = chunk.finishReason ?? finishReason;
+        mergeToolCallDeltas(toolCalls, chunk.toolCalls);
+        if (chunk.reasoning) {
+            reasoningOutput += chunk.reasoning;
+            emit({ type: 'ReasoningToken', data: chunk.reasoning });
+        }
+        if (chunk.content) {
+            output += chunk.content;
+            emit({ type: 'Token', data: chunk.content });
+        }
+    }
+    return { output, reasoningOutput, usage, finishReason, toolCalls: [...toolCalls.values()] };
+}
+function drainSseEvents(input) {
+    const events = [];
+    let remaining = input;
+    let hasSeparator = true;
+    while (hasSeparator) {
+        const separator = findNextSeparator(remaining);
+        if (!separator) {
+            hasSeparator = false;
+            continue;
+        }
+        if (separator) {
+            events.push(remaining.slice(0, separator.index));
+            remaining = remaining.slice(separator.index + separator.length);
+        }
+    }
+    return { events, remaining };
+}
+function findNextSeparator(input) {
+    const crlf = input.indexOf('\r\n\r\n');
+    const lf = input.indexOf('\n\n');
+    if (crlf === -1 && lf === -1)
+        return undefined;
+    if (crlf !== -1 && (lf === -1 || crlf < lf))
+        return { index: crlf, length: 4 };
+    return { index: lf, length: 2 };
+}
+function parseSseData(event) {
+    const data = event
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('data:'))
+        .map((line) => line.slice(5).trim())
+        .join('\n');
+    if (!data)
+        return { done: false };
+    if (data === '[DONE]')
+        return { done: true };
+    const json = JSON.parse(data);
+    const delta = readDelta(json);
+    return {
+        done: false,
+        content: readString(delta.content),
+        reasoning: readString(delta.reasoning_content ?? delta.reasoning),
+        usage: readUsage(json),
+        finishReason: readFinishReason(json),
+        toolCalls: readToolCallDeltas(delta.tool_calls),
+    };
+}
+function readToolCallDeltas(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((item, arrayIndex) => {
+        if (!isRecord(item))
+            return [];
+        const fn = isRecord(item.function) ? item.function : {};
+        const index = typeof item.index === 'number' && Number.isInteger(item.index) ? item.index : arrayIndex;
+        return [{
+                index,
+                id: typeof item.id === 'string' ? item.id : '',
+                type: typeof item.type === 'string' ? item.type : 'function',
+                function: {
+                    name: typeof fn.name === 'string' ? fn.name : '',
+                    arguments: typeof fn.arguments === 'string' ? fn.arguments : '',
+                },
+            }];
+    });
+}
+function mergeToolCallDeltas(target, deltas) {
+    for (const delta of deltas ?? []) {
+        const current = target.get(delta.index);
+        target.set(delta.index, current ? {
+            index: delta.index,
+            id: delta.id || current.id,
+            type: delta.type || current.type,
+            function: {
+                name: delta.function.name || current.function.name,
+                arguments: current.function.arguments + delta.function.arguments,
+            },
+        } : delta);
+    }
+}
+function readUsage(value) {
+    if (!isRecord(value) || !isRecord(value.usage))
+        return undefined;
+    const usage = value.usage;
+    const inputDetails = isRecord(usage.prompt_tokens_details) ? usage.prompt_tokens_details : {};
+    const outputDetails = isRecord(usage.completion_tokens_details) ? usage.completion_tokens_details : {};
+    return {
+        inputTokens: readTokenCount(usage.prompt_tokens ?? usage.input_tokens),
+        outputTokens: readTokenCount(usage.completion_tokens ?? usage.output_tokens),
+        reasoningTokens: readTokenCount(outputDetails.reasoning_tokens ?? usage.reasoning_tokens),
+        cacheReadTokens: readTokenCount(inputDetails.cached_tokens ?? usage.cache_read_tokens),
+        cacheWriteTokens: readTokenCount(usage.cache_write_tokens),
+        totalTokens: readTokenCount(usage.total_tokens),
+    };
+}
+function readFinishReason(value) {
+    if (!isRecord(value) || !Array.isArray(value.choices))
+        return undefined;
+    const first = value.choices[0];
+    return isRecord(first) ? readString(first.finish_reason) : undefined;
+}
+function readDelta(value) {
+    if (!isRecord(value))
+        return {};
+    const choices = value.choices;
+    if (!Array.isArray(choices))
+        return {};
+    const first = choices[0];
+    if (!isRecord(first) || !isRecord(first.delta))
+        return {};
+    return first.delta;
+}
+function readString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function readTokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function normalizeBaseUrl(input, fallback) {
+    const raw = input?.trim() || fallback;
+    if (!raw) {
+        throw new Error('LLM baseUrl is required');
+    }
+    return raw.replace(/\/+$/, '');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,290 @@
+import type { LlmApiProtocol } from './providerProtocol.js';
+import type { LlmReasoningConfig } from './reasoning.js';
+export type { LlmReasoningConfig, LlmReasoningEffort } from './reasoning.js';
+export interface LlmCapabilities {
+    text: boolean;
+    image: boolean;
+    video: boolean;
+    audio: boolean;
+    /** 宿主已持有的文件 URL / 内联字节；不表示 SDK 提供供应商文件上传。 */
+    file?: boolean;
+    streaming: boolean;
+    toolCall: boolean;
+    parallelTools: boolean;
+    jsonOutput: boolean;
+    structuredOutputMode: 'none' | 'json' | 'schema';
+    reasoning: boolean;
+    sampling: boolean;
+    contextWindow: number | null;
+    maxOutputTokens: number | null;
+    usage: boolean;
+}
+export interface LlmProviderConfig {
+    providerId: string;
+    /** 供应商协议族；区域化或多租户实例共享同一套协议规则。 */
+    providerFamilyId?: string;
+    /** 当前实例选择的端点 profile。 */
+    endpointProfile?: string;
+    /** RuntimeContext.credentials 的独立凭据槽；省略时兼容使用 providerId。 */
+    credentialId?: string;
+    /** 供应商配置来源与生命周期；旧配置缺省值只允许由宿主归一化一次。 */
+    setup?: LlmProviderSetup;
+    displayName: string;
+    adapter: string;
+    apiProtocol?: LlmApiProtocol;
+    baseUrl?: string;
+    reasoning?: LlmReasoningConfig;
+    reasoningConfigurable?: boolean;
+    enabled: boolean;
+}
+export type LlmProviderSetup = {
+    kind: 'preset';
+    presetId: string;
+    /** 内置记录不可永久删除；user 预设实例可以删除。 */
+    lifecycle: 'builtin' | 'user';
+    /**
+     * 预设连接信息的显式覆盖。缺省时继续使用 SDK 按模型维护的官方地址与首选协议；
+     * 宿主只有在用户主动编辑连接设置后才应写入这里。
+     */
+    connectionOverrides?: {
+        baseUrl?: string;
+        apiProtocol?: LlmApiProtocol;
+    };
+} | {
+    kind: 'custom';
+    /** 自定义供应商可选的密钥管理页，只允许 HTTP(S)。 */
+    apiKeyManagementUrl?: string;
+};
+export interface LlmModelConfig {
+    providerId: string;
+    providerFamilyId?: string;
+    endpointProfile?: string;
+    credentialId?: string;
+    modelId: string;
+    displayName: string;
+    adapter: string;
+    apiProtocol?: LlmApiProtocol;
+    baseUrl?: string;
+    capabilities: LlmCapabilities;
+    /**
+     * 命中的内置模型能力目录条目 id（`src/core/llm/modelCatalog.ts`）。
+     *
+     * 只表示"这条配置已经按目录自动标注过一次"，用来避免归一化在每次保存时反复覆盖用户的手工修改；
+     * 值为空且模型 ID 能查到目录条目时，归一化会补一次标注并写上这个字段。
+     */
+    catalogId?: string;
+    pricing?: {
+        currency: 'USD';
+        inputPerMillionTokens: number;
+        outputPerMillionTokens: number;
+        cacheReadPerMillionTokens?: number;
+        cacheWritePerMillionTokens?: number;
+    };
+    enabled: boolean;
+}
+export type AgentModelRole = 'primary' | 'router' | 'summarizer' | 'fallback' | 'observer';
+export interface AgentModelReference {
+    providerId: string;
+    modelId: string;
+}
+/**
+ * 智能助手能力验证快照，结构与 `capabilitySmoke.ts` 的 `ModelCapabilitySmokeResult` 一致。
+ *
+ * `capabilitySmoke.ts`/`capabilitySmokeCapabilities.ts` 目前仍留在痕迹AI 应用侧（任务 4.1
+ * 明确划定的迁移范围之外，见 docs/task/模型SDK抽离/任务/第四阶段-大语言模型迁移/4.1-迁移LLM协议与目录层.md），
+ * 但 `AgentModelProfile.verifications` 的实际读写方（`LlmConfigService.ts`、
+ * `AgentModelProfilesSection.tsx`）都按这份具体字段结构做属性访问，不能简单改成 `unknown`——
+ * 那会让这些消费方在数组元素上的每一次属性访问都报错。这里按字段结构复刻一份而不是反向导入
+ * `./capabilitySmoke`（那样会让 SDK 依赖尚未迁移的应用侧模块），TypeScript 是结构类型系统，
+ * `ModelCapabilitySmokeResult` 的值可以直接赋给这个类型，调用方不需要任何显式转换。
+ * `capabilitySmoke.ts` 迁入 SDK 后应删除这份复刻，直接复用同一个类型。
+ */
+export interface AgentModelCapabilityVerification {
+    providerId: string;
+    modelId: string;
+    adapterVersion: string;
+    verifiedAt: string;
+    checks: Array<{
+        id: 'text' | 'toolCall' | 'structuredOutput' | 'streaming' | 'usage' | 'cancel' | 'image' | 'video' | 'audio';
+        status: 'passed' | 'failed' | 'skipped';
+        latencyMs: number;
+        errorCode?: string;
+    }>;
+    totalLatencyMs: number;
+    usage: {
+        inputTokens: number | null;
+        outputTokens: number | null;
+        reasoningTokens: number | null;
+        cacheReadTokens: number | null;
+        cacheWriteTokens: number | null;
+        totalTokens: number | null;
+    };
+    cost: {
+        status: 'unknown';
+    } | {
+        status: 'known';
+        amount: number;
+        currency: string;
+    };
+}
+export interface AgentModelProfile {
+    id: string;
+    name: string;
+    primary: AgentModelReference;
+    router?: AgentModelReference;
+    summarizer?: AgentModelReference;
+    fallback?: AgentModelReference;
+    observer?: AgentModelReference;
+    settings: {
+        timeoutMs: number;
+        maxRetries: number;
+        maxOutputTokens: number;
+        contextWindowBudget: number;
+        temperature?: number;
+    };
+    verifications: AgentModelCapabilityVerification[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PromptOptimizationProfile {
+    id: string;
+    name: string;
+    providerId: string;
+    modelId: string;
+    systemPrompt: string;
+    /**
+     * 富文本提示词文档（痕迹AI 画布的 `PromptDocumentV1`，定义于 `@/core/inputs/promptDocument`）。
+     *
+     * SDK 侧特意不引入 `PromptDocumentV1`——那是一个体量不小、仍在演进的画布专属文档格式，
+     * 与"供应商无关的模型协议类型"无关，具体类型留给应用侧。这里只保留字段位置，类型标成
+     * `unknown`；唯一真正读写这个字段内部结构的地方（`src/core/llm/promptOptimization.ts`）
+     * 已经把它传给同样以 `unknown` 接收 `document` 的 `readPromptDocument()`，不需要显式转换。
+     */
+    systemPromptDocument?: unknown;
+    userTemplate: string;
+    userTemplateDocument?: unknown;
+    capabilities: Pick<LlmCapabilities, 'text' | 'image' | 'video'>;
+    isDefault: boolean;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TextProcessingPromptTemplate {
+    id: string;
+    name: string;
+    systemPrompt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * `inputSchema`/`outputSchema` 原用项目全局的 `DynamicValue`（等价于 `any`，声明于
+ * `src/types/dynamic-value.d.ts` 的 `declare global`）。SDK 是独立源码包，不依赖本仓库的全局
+ * 环境声明，这里改用 `unknown`——比 `any` 更安全，且调用方目前都是原样透传，不做属性访问，
+ * 收窄类型不影响任何现有用法。
+ */
+export interface LlmToolSchema {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+}
+export interface LlmPolicy {
+    allowedTools: string[];
+    requireHumanConfirmation: boolean;
+    maxTokens?: number;
+}
+export interface LlmMemoryScope {
+    sessionId?: string;
+    conversationId?: string;
+    longTermNamespace?: string;
+}
+export interface LlmConfigState {
+    providers: LlmProviderConfig[];
+    models: LlmModelConfig[];
+    promptProfiles: PromptOptimizationProfile[];
+    selectedPromptProfileId?: string;
+    textProcessingPromptTemplates: TextProcessingPromptTemplate[];
+    agentProfiles: AgentModelProfile[];
+    selectedAgentProfileId?: string;
+    tools: LlmToolSchema[];
+    policy: LlmPolicy;
+    memory: LlmMemoryScope;
+}
+export interface LlmTrace {
+    providerId: string;
+    modelId: string;
+    startedAtMs: number;
+    elapsedMs: number;
+    inputChars: number;
+    outputChars: number;
+}
+export type LlmStreamEvent = {
+    type: 'Token';
+    data: string;
+} | {
+    type: 'ReasoningToken';
+    data: string;
+} | {
+    type: 'Done';
+    data: LlmTrace;
+} | {
+    type: 'Error';
+    data: string;
+};
+export interface LlmImageUrlPart {
+    type: 'image_url';
+    imageUrl: {
+        url: string;
+    };
+}
+export interface LlmVideoUrlPart {
+    type: 'video_url';
+    videoUrl: {
+        url: string;
+    };
+}
+export interface LlmInputAudioPart {
+    type: 'input_audio';
+    inputAudio: {
+        data: string;
+        format: string;
+    };
+}
+export interface LlmFilePart {
+    type: 'file';
+    file: {
+        /** 宿主已取得的可访问 URL；SDK 不负责创建或上传 file_id。 */
+        fileUrl?: string;
+        /** Base64/供应商已接受的内联内容。 */
+        fileData?: string;
+        filename?: string;
+    };
+}
+export interface LlmTextPart {
+    type: 'text';
+    text: string;
+}
+export type LlmMessageContentPart = LlmTextPart | LlmImageUrlPart | LlmVideoUrlPart | LlmInputAudioPart | LlmFilePart;
+export interface LlmChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | LlmMessageContentPart[] | null;
+    name?: string | null;
+}
+export interface LlmChatRequest {
+    requestId?: string;
+    providerId: string;
+    providerFamilyId?: string;
+    endpointProfile?: string;
+    credentialId?: string;
+    modelId: string;
+    adapter?: string;
+    baseUrl?: string;
+    reasoning?: LlmReasoningConfig;
+    messages: LlmChatMessage[];
+    capabilities?: Partial<LlmCapabilities>;
+    tools?: LlmToolSchema[];
+    policy?: Partial<LlmPolicy>;
+    memory?: LlmMemoryScope;
+    /** 原用项目全局的 `DynamicValueMap`（`Record<string, any>`），SDK 侧改用 `Record<string, unknown>`。 */
+    metadata?: Record<string, unknown>;
+}

package/dist/llm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/llm/utf8-stream-decoder.d.ts

@@ -0,0 +1 @@
+export * from '../protocols/utf8-stream-decoder.js';

package/dist/llm/utf8-stream-decoder.js

@@ -0,0 +1,2 @@
+// 兼容原有内部路径；真正实现位于供应商无关的协议层，供 LLM 与翻译 SSE 共用。
+export * from '../protocols/utf8-stream-decoder.js';

package/dist/packs/models/apimart/gemini-omni-flash.d.ts

@@ -0,0 +1,6 @@
+/** 由 scripts/generate-catalog-index.cjs 自动生成；`pack` 是完整执行单元，`model` 仅供低层目录用途。 */
+import model from '../../../catalog/apimart/gemini-omni-flash.model.js';
+import type { GenerationClientProviderRegistration, GenerationPack } from '../../../generation/core.js';
+export { model };
+export declare const provider: GenerationClientProviderRegistration;
+export declare const pack: GenerationPack;

package/dist/packs/models/apimart/gemini-omni-flash.js

@@ -0,0 +1,7 @@
+/** 由 scripts/generate-catalog-index.cjs 自动生成；`pack` 是完整执行单元，`model` 仅供低层目录用途。 */
+import model from '../../../catalog/apimart/gemini-omni-flash.model.js';
+import * as adapter from '../../../providers/apimart.js';
+import { preprocess } from '../../../upload/provider-preprocessors/apimart.js';
+export { model };
+export const provider = { id: 'apimart', adapter, preprocess };
+export const pack = { models: [model], providers: [provider] };

package/dist/packs/models/apimart/gpt-image-2.d.ts

@@ -0,0 +1,6 @@
+/** 由 scripts/generate-catalog-index.cjs 自动生成；`pack` 是完整执行单元，`model` 仅供低层目录用途。 */
+import model from '../../../catalog/apimart/gpt-image-2.model.js';
+import type { GenerationClientProviderRegistration, GenerationPack } from '../../../generation/core.js';
+export { model };
+export declare const provider: GenerationClientProviderRegistration;
+export declare const pack: GenerationPack;

package/dist/packs/models/apimart/gpt-image-2.js

@@ -0,0 +1,7 @@
+/** 由 scripts/generate-catalog-index.cjs 自动生成；`pack` 是完整执行单元，`model` 仅供低层目录用途。 */
+import model from '../../../catalog/apimart/gpt-image-2.model.js';
+import * as adapter from '../../../providers/apimart.js';
+import { preprocess } from '../../../upload/provider-preprocessors/apimart.js';
+export { model };
+export const provider = { id: 'apimart', adapter, preprocess };
+export const pack = { models: [model], providers: [provider] };

package/dist/packs/models/apimart/grok-imagine-2.0.d.ts

@@ -0,0 +1,6 @@
+/** 由 scripts/generate-catalog-index.cjs 自动生成；`pack` 是完整执行单元，`model` 仅供低层目录用途。 */
+import model from '../../../catalog/apimart/grok-imagine-2.0.model.js';
+import type { GenerationClientProviderRegistration, GenerationPack } from '../../../generation/core.js';
+export { model };
+export declare const provider: GenerationClientProviderRegistration;
+export declare const pack: GenerationPack;

package/dist/packs/models/apimart/grok-imagine-2.0.js

@@ -0,0 +1,7 @@
+/** 由 scripts/generate-catalog-index.cjs 自动生成；`pack` 是完整执行单元，`model` 仅供低层目录用途。 */
+import model from '../../../catalog/apimart/grok-imagine-2.0.model.js';
+import * as adapter from '../../../providers/apimart.js';
+import { preprocess } from '../../../upload/provider-preprocessors/apimart.js';
+export { model };
+export const provider = { id: 'apimart', adapter, preprocess };
+export const pack = { models: [model], providers: [provider] };

package/dist/packs/models/apimart/kling-3.0-omni.d.ts

@@ -0,0 +1,6 @@
+/** 由 scripts/generate-catalog-index.cjs 自动生成；`pack` 是完整执行单元，`model` 仅供低层目录用途。 */
+import model from '../../../catalog/apimart/kling-3.0-omni.model.js';
+import type { GenerationClientProviderRegistration, GenerationPack } from '../../../generation/core.js';
+export { model };
+export declare const provider: GenerationClientProviderRegistration;
+export declare const pack: GenerationPack;