@henjicc/ai-sdk 0.2.8 → 0.3.0

package/dist/capabilities/embedding/bailian.d.ts

@@ -0,0 +1,23 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const bailianEmbeddingPresets: {
+    readonly 'qwen3.7-text-embedding': {
+        readonly modelId: "qwen3.7-text-embedding";
+        readonly maxBatchSize: 20;
+        readonly dimensions: readonly [256, 512, 768, 1024, 1536, 2048, 2560];
+    };
+    readonly 'qwen3.7-text-embedding-flash': {
+        readonly modelId: "qwen3.7-text-embedding-flash";
+        readonly maxBatchSize: 20;
+        readonly dimensions: readonly [256, 512, 768, 1024];
+    };
+    readonly 'text-embedding-v4': {
+        readonly modelId: "text-embedding-v4";
+        readonly maxBatchSize: 10;
+        readonly dimensions: readonly [64, 128, 256, 512, 768, 1024, 1536, 2048];
+    };
+};
+/** baseUrl is the actual workspace/region API root, without the endpoint path. */
+export declare function createBailianEmbeddingModule(config: RetrievalModuleConfig & {
+    baseUrl: string;
+    model?: keyof typeof bailianEmbeddingPresets;
+}): import("./index.js").EmbeddingModule;

package/dist/capabilities/embedding/bailian.js

@@ -0,0 +1,10 @@
+import { embeddingModule } from '../retrieval/module.js';
+export const bailianEmbeddingPresets = {
+    'qwen3.7-text-embedding': { modelId: 'qwen3.7-text-embedding', maxBatchSize: 20, dimensions: [256, 512, 768, 1024, 1536, 2048, 2560] },
+    'qwen3.7-text-embedding-flash': { modelId: 'qwen3.7-text-embedding-flash', maxBatchSize: 20, dimensions: [256, 512, 768, 1024] },
+    'text-embedding-v4': { modelId: 'text-embedding-v4', maxBatchSize: 10, dimensions: [64, 128, 256, 512, 768, 1024, 1536, 2048] },
+};
+/** baseUrl is the actual workspace/region API root, without the endpoint path. */
+export function createBailianEmbeddingModule(config) {
+    return embeddingModule(bailianEmbeddingPresets[config.model ?? 'qwen3.7-text-embedding'], { providerId: 'bailian', path: '/compatible-mode/v1/embeddings' }, config);
+}

package/dist/capabilities/embedding/bigmodel.d.ts

@@ -0,0 +1,9 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const bigmodelEmbeddingPresets: {
+    readonly 'embedding-3': {
+        readonly modelId: "embedding-3";
+        readonly maxBatchSize: 64;
+        readonly dimensions: readonly [256, 512, 1024, 2048];
+    };
+};
+export declare function createBigmodelEmbeddingModule(config?: RetrievalModuleConfig): import("./index.js").EmbeddingModule;

package/dist/capabilities/embedding/bigmodel.js

@@ -0,0 +1,5 @@
+import { embeddingModule } from '../retrieval/module.js';
+export const bigmodelEmbeddingPresets = { 'embedding-3': { modelId: 'embedding-3', maxBatchSize: 64, dimensions: [256, 512, 1024, 2048] } };
+export function createBigmodelEmbeddingModule(config = {}) {
+    return embeddingModule(bigmodelEmbeddingPresets['embedding-3'], { providerId: 'bigmodel', baseUrl: 'https://open.bigmodel.cn', path: '/api/paas/v4/embeddings', floatEncoding: false }, config);
+}

package/dist/capabilities/embedding/index.d.ts

@@ -0,0 +1 @@
+export type { EmbeddingInput, EmbeddingOutput, EmbeddingModule, EmbeddingPreset, RetrievalUsage, RetrievalModuleConfig } from '../retrieval/types.js';

package/dist/capabilities/embedding/index.js

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

package/dist/capabilities/embedding/ppio.d.ts

@@ -0,0 +1,7 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const ppioEmbeddingPresets: {
+    readonly 'baai/bge-m3': {
+        readonly modelId: "baai/bge-m3";
+    };
+};
+export declare function createPpioEmbeddingModule(config?: RetrievalModuleConfig): import("./index.js").EmbeddingModule;

package/dist/capabilities/embedding/ppio.js

@@ -0,0 +1,5 @@
+import { embeddingModule } from '../retrieval/module.js';
+export const ppioEmbeddingPresets = { 'baai/bge-m3': { modelId: 'baai/bge-m3' } };
+export function createPpioEmbeddingModule(config = {}) {
+    return embeddingModule(ppioEmbeddingPresets['baai/bge-m3'], { providerId: 'ppio', baseUrl: 'https://api.ppio.com', path: '/openai/v1/embeddings' }, config);
+}

package/dist/capabilities/embedding/siliconflow.d.ts

@@ -0,0 +1,21 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const siliconflowEmbeddingPresets: {
+    readonly 'Qwen/Qwen3-Embedding-8B': {
+        readonly modelId: "Qwen/Qwen3-Embedding-8B";
+        readonly dimensions: readonly [64, 128, 256, 512, 768, 1024, 1536, 2048, 2560, 4096];
+    };
+    readonly 'Qwen/Qwen3-Embedding-4B': {
+        readonly modelId: "Qwen/Qwen3-Embedding-4B";
+        readonly dimensions: readonly [64, 128, 256, 512, 768, 1024, 1536, 2048, 2560];
+    };
+    readonly 'Qwen/Qwen3-Embedding-0.6B': {
+        readonly modelId: "Qwen/Qwen3-Embedding-0.6B";
+        readonly dimensions: readonly [64, 128, 256, 512, 768, 1024];
+    };
+    readonly 'BAAI/bge-m3': {
+        readonly modelId: "BAAI/bge-m3";
+    };
+};
+export declare function createSiliconflowEmbeddingModule(config?: RetrievalModuleConfig & {
+    model?: keyof typeof siliconflowEmbeddingPresets;
+}): import("./index.js").EmbeddingModule;

package/dist/capabilities/embedding/siliconflow.js

@@ -0,0 +1,10 @@
+import { embeddingModule } from '../retrieval/module.js';
+export const siliconflowEmbeddingPresets = {
+    'Qwen/Qwen3-Embedding-8B': { modelId: 'Qwen/Qwen3-Embedding-8B', dimensions: [64, 128, 256, 512, 768, 1024, 1536, 2048, 2560, 4096] },
+    'Qwen/Qwen3-Embedding-4B': { modelId: 'Qwen/Qwen3-Embedding-4B', dimensions: [64, 128, 256, 512, 768, 1024, 1536, 2048, 2560] },
+    'Qwen/Qwen3-Embedding-0.6B': { modelId: 'Qwen/Qwen3-Embedding-0.6B', dimensions: [64, 128, 256, 512, 768, 1024] },
+    'BAAI/bge-m3': { modelId: 'BAAI/bge-m3' },
+};
+export function createSiliconflowEmbeddingModule(config = {}) {
+    return embeddingModule(siliconflowEmbeddingPresets[config.model ?? 'Qwen/Qwen3-Embedding-8B'], { providerId: 'siliconflow', baseUrl: 'https://api.siliconflow.cn', path: '/v1/embeddings' }, config);
+}

package/dist/capabilities/embedding/volcengine.d.ts

@@ -0,0 +1,10 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+/** Text-only entry: one text per call, so Ark never fuses independent documents. */
+export declare const volcengineEmbeddingPresets: {
+    readonly 'doubao-embedding-vision-251215': {
+        readonly modelId: "doubao-embedding-vision-251215";
+        readonly maxBatchSize: 1;
+        readonly dimensions: readonly [1024, 2048];
+    };
+};
+export declare function createVolcengineEmbeddingModule(config?: RetrievalModuleConfig): import("./index.js").EmbeddingModule;

package/dist/capabilities/embedding/volcengine.js

@@ -0,0 +1,6 @@
+import { embeddingModule } from '../retrieval/module.js';
+/** Text-only entry: one text per call, so Ark never fuses independent documents. */
+export const volcengineEmbeddingPresets = { 'doubao-embedding-vision-251215': { modelId: 'doubao-embedding-vision-251215', maxBatchSize: 1, dimensions: [1024, 2048] } };
+export function createVolcengineEmbeddingModule(config = {}) {
+    return embeddingModule(volcengineEmbeddingPresets['doubao-embedding-vision-251215'], { providerId: 'volcengine', baseUrl: 'https://ark.cn-beijing.volces.com', path: '/api/v3/embeddings/multimodal', envelope: 'ark-single' }, config);
+}

package/dist/capabilities/rerank/bailian.d.ts

@@ -0,0 +1,21 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const bailianRerankPresets: {
+    readonly 'qwen3.7-text-rerank': {
+        readonly modelId: "qwen3.7-text-rerank";
+        readonly maxDocuments: 500;
+        readonly instructionField: "instruct";
+    };
+    readonly 'qwen3-rerank': {
+        readonly modelId: "qwen3-rerank";
+        readonly maxDocuments: 500;
+        readonly instructionField: "instruct";
+    };
+    readonly 'gte-rerank-v2': {
+        readonly modelId: "gte-rerank-v2";
+        readonly maxDocuments: 500;
+    };
+};
+export declare function createBailianRerankModule(config: RetrievalModuleConfig & {
+    baseUrl: string;
+    model?: keyof typeof bailianRerankPresets;
+}): import("./index.js").RerankModule;

package/dist/capabilities/rerank/bailian.js

@@ -0,0 +1,14 @@
+import { rerankModule } from '../retrieval/module.js';
+export const bailianRerankPresets = {
+    'qwen3.7-text-rerank': { modelId: 'qwen3.7-text-rerank', maxDocuments: 500, instructionField: 'instruct' },
+    'qwen3-rerank': { modelId: 'qwen3-rerank', maxDocuments: 500, instructionField: 'instruct' },
+    'gte-rerank-v2': { modelId: 'gte-rerank-v2', maxDocuments: 500 },
+};
+export function createBailianRerankModule(config) {
+    const model = config.model ?? 'qwen3.7-text-rerank';
+    return rerankModule(bailianRerankPresets[model], {
+        providerId: 'bailian',
+        path: model === 'qwen3-rerank' ? '/compatible-api/v1/reranks' : '/api/v1/services/rerank/text-rerank/text-rerank',
+        envelope: model === 'qwen3-rerank' ? undefined : 'bailian',
+    }, config);
+}

package/dist/capabilities/rerank/bigmodel.d.ts

@@ -0,0 +1,9 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const bigmodelRerankPresets: {
+    readonly rerank: {
+        readonly modelId: "rerank";
+        readonly maxDocuments: 128;
+        readonly maxTextCharacters: 4096;
+    };
+};
+export declare function createBigmodelRerankModule(config?: RetrievalModuleConfig): import("./index.js").RerankModule;

package/dist/capabilities/rerank/bigmodel.js

@@ -0,0 +1,5 @@
+import { rerankModule } from '../retrieval/module.js';
+export const bigmodelRerankPresets = { rerank: { modelId: 'rerank', maxDocuments: 128, maxTextCharacters: 4096 } };
+export function createBigmodelRerankModule(config = {}) {
+    return rerankModule(bigmodelRerankPresets.rerank, { providerId: 'bigmodel', baseUrl: 'https://open.bigmodel.cn', path: '/api/paas/v4/rerank' }, config);
+}

package/dist/capabilities/rerank/index.d.ts

@@ -0,0 +1 @@
+export type { RerankInput, RerankOutput, RerankModule, RerankPreset, RetrievalUsage, RetrievalModuleConfig } from '../retrieval/types.js';

package/dist/capabilities/rerank/index.js

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

package/dist/capabilities/rerank/ppio.d.ts

@@ -0,0 +1,7 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const ppioRerankPresets: {
+    readonly 'baai/bge-reranker-v2-m3': {
+        readonly modelId: "baai/bge-reranker-v2-m3";
+    };
+};
+export declare function createPpioRerankModule(config?: RetrievalModuleConfig): import("./index.js").RerankModule;

package/dist/capabilities/rerank/ppio.js

@@ -0,0 +1,5 @@
+import { rerankModule } from '../retrieval/module.js';
+export const ppioRerankPresets = { 'baai/bge-reranker-v2-m3': { modelId: 'baai/bge-reranker-v2-m3' } };
+export function createPpioRerankModule(config = {}) {
+    return rerankModule(ppioRerankPresets['baai/bge-reranker-v2-m3'], { providerId: 'ppio', baseUrl: 'https://api.ppio.com', path: '/openai/v1/rerank' }, config);
+}

package/dist/capabilities/rerank/siliconflow.d.ts

@@ -0,0 +1,21 @@
+import type { RetrievalModuleConfig } from '../retrieval/types.js';
+export declare const siliconflowRerankPresets: {
+    readonly 'Qwen/Qwen3-Reranker-8B': {
+        readonly modelId: "Qwen/Qwen3-Reranker-8B";
+        readonly instructionField: "instruction";
+    };
+    readonly 'Qwen/Qwen3-Reranker-4B': {
+        readonly modelId: "Qwen/Qwen3-Reranker-4B";
+        readonly instructionField: "instruction";
+    };
+    readonly 'Qwen/Qwen3-Reranker-0.6B': {
+        readonly modelId: "Qwen/Qwen3-Reranker-0.6B";
+        readonly instructionField: "instruction";
+    };
+    readonly 'BAAI/bge-reranker-v2-m3': {
+        readonly modelId: "BAAI/bge-reranker-v2-m3";
+    };
+};
+export declare function createSiliconflowRerankModule(config?: RetrievalModuleConfig & {
+    model?: keyof typeof siliconflowRerankPresets;
+}): import("./index.js").RerankModule;

package/dist/capabilities/rerank/siliconflow.js

@@ -0,0 +1,10 @@
+import { rerankModule } from '../retrieval/module.js';
+export const siliconflowRerankPresets = {
+    'Qwen/Qwen3-Reranker-8B': { modelId: 'Qwen/Qwen3-Reranker-8B', instructionField: 'instruction' },
+    'Qwen/Qwen3-Reranker-4B': { modelId: 'Qwen/Qwen3-Reranker-4B', instructionField: 'instruction' },
+    'Qwen/Qwen3-Reranker-0.6B': { modelId: 'Qwen/Qwen3-Reranker-0.6B', instructionField: 'instruction' },
+    'BAAI/bge-reranker-v2-m3': { modelId: 'BAAI/bge-reranker-v2-m3' },
+};
+export function createSiliconflowRerankModule(config = {}) {
+    return rerankModule(siliconflowRerankPresets[config.model ?? 'Qwen/Qwen3-Reranker-8B'], { providerId: 'siliconflow', baseUrl: 'https://api.siliconflow.cn', path: '/v1/rerank' }, config);
+}

package/dist/capabilities/retrieval/http.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityExecutionContext } from '../types.js';
+export declare function apiRoot(value: string | undefined): string;
+export declare function requestJson(context: CapabilityExecutionContext, providerId: string, credentialId: string, kind: 'embedding' | 'rerank', endpoint: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;

package/dist/capabilities/retrieval/http.js

@@ -0,0 +1,48 @@
+import { fetchProvider } from '../../providers/provider-fetch.js';
+import { AiRuntimeError } from '../../runtime/AiRuntimeError.js';
+import { invalidInput, invalidResponse, record } from './validation.js';
+export function apiRoot(value) {
+    if (typeof value !== 'string' || !value.trim())
+        invalidInput('A region/workspace API baseUrl is required');
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return invalidInput('Invalid API baseUrl');
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash || /[{}]/.test(value)) {
+        invalidInput('API baseUrl must be HTTP(S), without credentials, placeholders, query or fragment');
+    }
+    return value.trim().replace(/\/+$/, '');
+}
+export async function requestJson(context, providerId, credentialId, kind, endpoint, body) {
+    context.signal.throwIfAborted();
+    const key = await context.runtime.credentials.get(kind, credentialId);
+    if (!key?.trim())
+        throw new AiRuntimeError('api_key_missing', `${providerId} ${kind} API key is not configured`);
+    context.signal.throwIfAborted();
+    const response = await fetchProvider(`${providerId} ${kind}`, endpoint, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${key.trim()}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        signal: context.signal,
+    }, { transport: context.runtime.transport, retryPreconnectOnce: false });
+    // Read even error responses to release the underlying response body. Never log body content.
+    const responseText = await response.text();
+    context.signal.throwIfAborted();
+    if (!response.ok)
+        throw new AiRuntimeError('provider_error', `${providerId} ${kind} failed with HTTP ${response.status}`);
+    let decoded;
+    try {
+        decoded = JSON.parse(responseText);
+    }
+    catch {
+        return invalidResponse('Provider returned invalid JSON');
+    }
+    const raw = record(decoded, 'response');
+    if (raw.error || (raw.code !== undefined && raw.code !== null && raw.code !== '' && raw.code !== 0)) {
+        throw new AiRuntimeError('provider_error', `${providerId} ${kind} returned a provider error`);
+    }
+    return raw;
+}

package/dist/capabilities/retrieval/module.d.ts

@@ -0,0 +1,11 @@
+import type { EmbeddingModule, EmbeddingPreset, RerankModule, RerankPreset, RetrievalModuleConfig } from './types.js';
+interface ProviderContract {
+    providerId: string;
+    baseUrl?: string;
+    path: string;
+    envelope?: 'bailian' | 'ark-single';
+    floatEncoding?: boolean;
+}
+export declare function embeddingModule(preset: EmbeddingPreset, provider: ProviderContract, config?: RetrievalModuleConfig): EmbeddingModule;
+export declare function rerankModule(preset: RerankPreset, provider: ProviderContract, config?: RetrievalModuleConfig): RerankModule;
+export {};

package/dist/capabilities/retrieval/module.js

@@ -0,0 +1,110 @@
+import { apiRoot, requestJson } from './http.js';
+import { inputRecord, invalidInput, invalidResponse, positiveInteger, record, responseIndex, text, texts, usage } from './validation.js';
+function descriptor(kind, modelId, providerId, moduleId) {
+    return {
+        id: moduleId ?? `${providerId}.${kind}.${modelId}`,
+        kind,
+        source: { kind: 'builtin', namespace: '@henjicc/ai-sdk' },
+        version: '1', providerIds: [providerId], modelId,
+        contract: { input: [{ kind: 'text', required: true, multiple: true }], output: [{ kind: 'structured-data', required: true }] },
+        operations: [kind], executionModes: ['request-response'],
+    };
+}
+async function traced(context, providerId, modelId, kind, run) {
+    const fields = { requestId: context.requestId, providerId, modelId };
+    const span = context.runtime.tracer.startSpan(`${kind}.request`, fields);
+    context.runtime.logger.info(`${kind} request started`, { ...fields, event: `${kind}.request.start` });
+    try {
+        const output = await run();
+        context.signal.throwIfAborted();
+        context.runtime.logger.info(`${kind} request completed`, { ...fields, event: `${kind}.request.completed` });
+        span.end();
+        return output;
+    }
+    catch (error) {
+        // Error details may contain provider echoes of input or credentials; log only the stage.
+        context.runtime.logger.error(`${kind} request failed`, { ...fields, event: `${kind}.request.failed` });
+        span.end();
+        throw error;
+    }
+}
+export function embeddingModule(preset, provider, config = {}) {
+    if (!preset)
+        invalidInput('Unknown embedding model');
+    const endpoint = apiRoot(config.baseUrl ?? provider.baseUrl) + provider.path;
+    return {
+        descriptor: descriptor('embedding', preset.modelId, provider.providerId, config.moduleId),
+        execute: (input, context) => traced(context, provider.providerId, preset.modelId, 'embedding', async () => {
+            const rawInput = inputRecord(input, ['texts', 'dimensions']);
+            const source = texts(rawInput.texts, 'texts', preset.maxBatchSize, preset.maxTextCharacters);
+            const body = { model: preset.modelId, input: source };
+            if (provider.envelope === 'ark-single')
+                body.input = [{ type: 'text', text: source[0] }];
+            if (provider.floatEncoding !== false)
+                body.encoding_format = 'float';
+            if (rawInput.dimensions !== undefined) {
+                const dimensions = positiveInteger(rawInput.dimensions, 'dimensions');
+                if (!preset.dimensions?.includes(dimensions))
+                    invalidInput('Unsupported embedding dimensions for this model');
+                body.dimensions = dimensions;
+            }
+            const raw = await requestJson(context, provider.providerId, config.credentialId ?? provider.providerId, 'embedding', endpoint, body);
+            const data = provider.envelope === 'ark-single' ? [{ ...record(raw.data, 'data'), index: 0 }] : raw.data;
+            if (!Array.isArray(data) || data.length !== source.length)
+                invalidResponse('Embedding result count must match the input count');
+            const seen = new Set();
+            let dimensionCount;
+            const embeddings = data.map(value => {
+                const item = record(value, 'embedding');
+                const index = responseIndex(item.index, source.length, seen);
+                if (!Array.isArray(item.embedding) || item.embedding.length === 0 || !item.embedding.every(n => typeof n === 'number' && Number.isFinite(n))) {
+                    invalidResponse('Embedding must contain a non-empty finite numeric vector');
+                }
+                const vector = item.embedding;
+                dimensionCount ??= vector.length;
+                if (vector.length !== dimensionCount || (rawInput.dimensions !== undefined && vector.length !== rawInput.dimensions))
+                    invalidResponse('Embedding vector dimensions do not match');
+                return { index, vector };
+            }).sort((a, b) => a.index - b.index);
+            return { embeddings, usage: usage(raw.usage) };
+        }),
+    };
+}
+export function rerankModule(preset, provider, config = {}) {
+    if (!preset)
+        invalidInput('Unknown rerank model');
+    const endpoint = apiRoot(config.baseUrl ?? provider.baseUrl) + provider.path;
+    return {
+        descriptor: descriptor('rerank', preset.modelId, provider.providerId, config.moduleId),
+        execute: (input, context) => traced(context, provider.providerId, preset.modelId, 'rerank', async () => {
+            const rawInput = inputRecord(input, ['query', 'documents', 'topN', 'instruction']);
+            const query = text(rawInput.query, 'query', preset.maxTextCharacters);
+            const documents = texts(rawInput.documents, 'documents', preset.maxDocuments, preset.maxTextCharacters);
+            const params = {};
+            if (rawInput.topN !== undefined)
+                params.top_n = Math.min(positiveInteger(rawInput.topN, 'topN'), documents.length);
+            if (rawInput.instruction !== undefined) {
+                if (!preset.instructionField)
+                    invalidInput('Instructions are not supported by this rerank model');
+                params[preset.instructionField] = text(rawInput.instruction, 'instruction');
+            }
+            const body = provider.envelope === 'bailian'
+                ? { model: preset.modelId, input: { query, documents }, parameters: params }
+                : { model: preset.modelId, query, documents, ...params };
+            const raw = await requestJson(context, provider.providerId, config.credentialId ?? provider.providerId, 'rerank', endpoint, body);
+            const payload = provider.envelope === 'bailian' ? record(raw.output, 'output') : raw;
+            if (!Array.isArray(payload.results) || payload.results.length === 0 || payload.results.length > (params.top_n ?? documents.length))
+                invalidResponse('Invalid rerank result count');
+            const seen = new Set();
+            const results = payload.results.map(value => {
+                const item = record(value, 'rerank result');
+                const index = responseIndex(item.index, documents.length, seen);
+                if (typeof item.relevance_score !== 'number' || !Number.isFinite(item.relevance_score))
+                    invalidResponse('Invalid rerank score');
+                return { index, score: item.relevance_score, document: documents[index] };
+            }).sort((a, b) => b.score - a.score);
+            const meta = raw.meta === undefined ? undefined : record(raw.meta, 'meta');
+            return { results, usage: usage(raw.usage ?? meta?.tokens) };
+        }),
+    };
+}

package/dist/capabilities/retrieval/types.d.ts

@@ -0,0 +1,54 @@
+import type { CapabilityModule } from '../types.js';
+export interface RetrievalUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface EmbeddingInput {
+    texts: readonly string[];
+    dimensions?: number;
+}
+export interface EmbeddingOutput {
+    /** Ordered by the original input index, independent of provider response order. */
+    embeddings: readonly {
+        index: number;
+        vector: readonly number[];
+    }[];
+    usage?: RetrievalUsage;
+}
+export interface RerankInput {
+    query: string;
+    documents: readonly string[];
+    topN?: number;
+    instruction?: string;
+}
+export interface RerankOutput {
+    /** Scores are comparable only within this request. */
+    results: readonly {
+        index: number;
+        score: number;
+        document: string;
+    }[];
+    usage?: RetrievalUsage;
+}
+export type EmbeddingModule = CapabilityModule<EmbeddingInput, EmbeddingOutput>;
+export type RerankModule = CapabilityModule<RerankInput, RerankOutput>;
+export interface RetrievalModuleConfig {
+    /** Exact API root for the selected region/workspace; never changed by the SDK. */
+    baseUrl?: string;
+    /** Separate credentials for accounts or regions, without changing provider identity. */
+    credentialId?: string;
+    moduleId?: string;
+}
+export interface EmbeddingPreset {
+    modelId: string;
+    dimensions?: readonly number[];
+    maxBatchSize?: number;
+    maxTextCharacters?: number;
+}
+export interface RerankPreset {
+    modelId: string;
+    maxDocuments?: number;
+    maxTextCharacters?: number;
+    instructionField?: 'instruction' | 'instruct';
+}

package/dist/capabilities/retrieval/types.js

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

package/dist/capabilities/retrieval/validation.d.ts

@@ -0,0 +1,10 @@
+import type { RetrievalUsage } from './types.js';
+export declare function invalidInput(message: string): never;
+export declare function invalidResponse(message: string): never;
+export declare function record(value: unknown, label: string): Record<string, unknown>;
+export declare function inputRecord(value: unknown, keys: readonly string[]): Record<string, unknown>;
+export declare function text(value: unknown, label: string, maxCharacters?: number): string;
+export declare function texts(value: unknown, label: string, maximum?: number, maxCharacters?: number): string[];
+export declare function positiveInteger(value: unknown, label: string): number;
+export declare function responseIndex(value: unknown, count: number, seen: Set<number>): number;
+export declare function usage(value: unknown): RetrievalUsage | undefined;

package/dist/capabilities/retrieval/validation.js

@@ -0,0 +1,65 @@
+import { AiRuntimeError } from '../../runtime/AiRuntimeError.js';
+export function invalidInput(message) {
+    throw new AiRuntimeError('invalid_parameter', message);
+}
+export function invalidResponse(message) {
+    throw new AiRuntimeError('invalid_response', message);
+}
+export function record(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        invalidResponse(`${label} must be an object`);
+    return value;
+}
+export function inputRecord(value, keys) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        invalidInput('Input must be an object');
+    const result = value;
+    for (const key of Object.keys(result))
+        if (!keys.includes(key))
+            invalidInput(`Unsupported input field: ${key}`);
+    return result;
+}
+export function text(value, label, maxCharacters) {
+    if (typeof value !== 'string' || !value.trim())
+        invalidInput(`${label} must be non-empty text`);
+    if (maxCharacters !== undefined && Array.from(value).length > maxCharacters)
+        invalidInput(`${label} exceeds ${maxCharacters} characters`);
+    return value;
+}
+export function texts(value, label, maximum, maxCharacters) {
+    if (!Array.isArray(value) || value.length === 0)
+        invalidInput(`${label} must be a non-empty array`);
+    if (maximum !== undefined && value.length > maximum)
+        invalidInput(`${label} exceeds ${maximum} items`);
+    return value.map((item, index) => text(item, `${label}[${index}]`, maxCharacters));
+}
+export function positiveInteger(value, label) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1)
+        invalidInput(`${label} must be a positive integer`);
+    return value;
+}
+export function responseIndex(value, count, seen) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0 || value >= count || seen.has(value)) {
+        invalidResponse('Result index is missing, duplicate or outside the input range');
+    }
+    seen.add(value);
+    return value;
+}
+export function usage(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const raw = record(value, 'usage');
+    const output = {};
+    for (const [target, source] of [
+        ['inputTokens', raw.prompt_tokens ?? raw.input_tokens],
+        ['outputTokens', raw.completion_tokens ?? raw.output_tokens],
+        ['totalTokens', raw.total_tokens],
+    ]) {
+        if (source === undefined || source === null)
+            continue;
+        if (typeof source !== 'number' || !Number.isSafeInteger(source) || source < 0)
+            invalidResponse(`Invalid usage.${target}`);
+        output[target] = source;
+    }
+    return Object.keys(output).length ? output : undefined;
+}

package/dist/capabilities/types.d.ts

@@ -1,6 +1,6 @@
 import type { ResolvedRuntimeContext } from '../runtime/RuntimeContext.js';
 type ExtensibleString = string & Record<never, never>;
-export type CapabilityKind = 'media-generation' | 'chat' | 'speech-recognition' | 'translation' | ExtensibleString;
+export type CapabilityKind = 'media-generation' | 'chat' | 'speech-recognition' | 'translation' | 'embedding' | 'rerank' | ExtensibleString;
 export type CapabilityContentKind = 'text' | 'structured-data' | 'image' | 'audio' | 'video' | 'pdf' | ExtensibleString;
 export interface CapabilityValueContract {
     kind: CapabilityContentKind;

package/dist/catalog/apimart/gpt-image-2.5.model.d.ts

@@ -0,0 +1,2 @@
+export declare const apimartGptImage25Model: import("../../index.js").ModelRuntimeDefinition;
+export default apimartGptImage25Model;

package/dist/catalog/apimart/gpt-image-2.5.model.js

@@ -0,0 +1,51 @@
+import { defineModel } from '../defineModel.js';
+import { GPT25_BACKGROUNDS, GPT25_EXT_RATIOS, GPT25_QUALITIES, GPT25_RATIOS, GPT25_RESOLUTIONS, gpt25Choice, gpt25Count, gpt25Images, gpt25Options, gpt25Prompt, gpt25Ratio } from '../shared/gptImage25.js';
+import { gpt25OutputEstimate } from '../shared/gptImage25Pricing.js';
+export const apimartGptImage25Model = defineModel({
+    meta: {
+        id: 'apimart-gpt-image-2.5', canonicalModelId: 'gpt-image-2.5', seriesId: 'gpt-image', seriesRank: 2.5,
+        provider: 'apimart', type: 'image',
+        tags: ['text-to-image', 'image-to-image', 'supports-image-editing', 'supports-multi-image', 'multi-output', 'supports-4k', 'provider-apimart'],
+        polling: { interval: 3000, maxAttempts: 200 },
+    },
+    inputLimits: { images: { max: 16 }, videos: { max: 0 } },
+    params: [
+        { id: 'gpt25Channel', type: 'dropdown', order: 1, default: 'ext', options: gpt25Options(['ext', 'official']) },
+        { id: 'gpt25Variant', type: 'dropdown', order: 2, default: 'flare', options: gpt25Options(['flare', 'sunburst']) },
+        { id: 'gpt25AspectRatio', type: 'dropdown', order: 3, default: 'smart', options: gpt25Options(['smart', ...GPT25_RATIOS]) },
+        { id: 'gpt25Resolution', type: 'dropdown', order: 4, default: '1K', options: gpt25Options(GPT25_RESOLUTIONS) },
+        { id: 'gpt25Quality', type: 'dropdown', order: 5, default: 'medium', options: gpt25Options(GPT25_QUALITIES), visible: { condition: p => p.gpt25Channel === 'official' } },
+        { id: 'gpt25Count', type: 'number', order: 6, default: 1, min: 1, max: 4, step: 1 },
+        { id: 'gpt25Background', type: 'dropdown', order: 7, default: 'auto', options: gpt25Options(GPT25_BACKGROUNDS), visible: { condition: p => p.gpt25Channel === 'official' } },
+    ],
+    endpoints: '/v1/images/generations',
+    request: { builder: params => {
+            const channel = gpt25Choice(params.gpt25Channel, ['ext', 'official'], 'ext');
+            const variant = gpt25Choice(params.gpt25Variant, ['flare', 'sunburst'], 'flare');
+            const resolution = gpt25Choice(params.gpt25Resolution, GPT25_RESOLUTIONS, '1K');
+            const body = {
+                model: channel === 'ext' ? 'gpt-image-2.5-ext' : `gpt-image-2.5-${variant}`,
+                prompt: gpt25Prompt(params), n: gpt25Count(params.gpt25Count, 4),
+                size: gpt25Ratio(params, params.gpt25AspectRatio, channel === 'ext' ? GPT25_EXT_RATIOS : GPT25_RATIOS),
+                resolution: channel === 'ext' ? resolution : resolution.toLowerCase(),
+            };
+            if (channel === 'ext')
+                body.version = variant;
+            else {
+                body.quality = gpt25Choice(params.gpt25Quality, GPT25_QUALITIES, 'medium');
+                body.background = gpt25Choice(params.gpt25Background, GPT25_BACKGROUNDS, 'auto');
+            }
+            const images = gpt25Images(params);
+            if (images.length)
+                body.image_urls = images;
+            return body;
+        } },
+    pricing: {
+        currency: '$',
+        calculator: params => params.gpt25Channel === 'official'
+            ? gpt25OutputEstimate(params, 24, 'medium')
+            : gpt25Count(params.gpt25Count, 4) * ({ '1K': 0.0085, '2K': 0.014, '4K': 0.021 }[gpt25Choice(params.gpt25Resolution, GPT25_RESOLUTIONS, '1K')] ?? 0.0085),
+        description: 'Ext按张：1K $0.0085 / 2K $0.014 / 4K $0.021；官方渠道按token，估算仅含输出，输入另计，自动质量按max预估',
+    },
+});
+export default apimartGptImage25Model;

package/dist/catalog/fal/gpt-image-2.5.model.d.ts

@@ -0,0 +1,2 @@
+export declare const falGptImage25Model: import("../../index.js").ModelRuntimeDefinition;
+export default falGptImage25Model;