@henjicc/ai-sdk 0.2.8

package/dist/runtime/error-classify.js

@@ -0,0 +1,192 @@
+import { ProviderModelStepError, } from './provider-error-core.js';
+import { shouldRetry as readPortableRetry } from './retry.js';
+export { describeNetworkFailure, shouldRetry } from './retry.js';
+const NETWORK_ERROR_CODES = new Set([
+    'ECONNRESET', 'ECONNREFUSED', 'ECONNABORTED', 'ETIMEDOUT', 'ENOTFOUND',
+    'EPIPE', 'EHOSTUNREACH', 'ENETUNREACH', 'ENETRESET', 'EAI_AGAIN',
+    'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT',
+    'UND_ERR_SOCKET', 'UND_ERR_CLOSED', 'UND_ERR_DESTROYED',
+]);
+function errorChain(error) {
+    const records = [];
+    const seen = new Set();
+    let current = error;
+    while (current && typeof current === 'object' && records.length < 4 && !seen.has(current)) {
+        seen.add(current);
+        const record = current;
+        records.push(record);
+        current = record.cause;
+    }
+    return records;
+}
+function nestedRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function jsonRecord(value) {
+    if (typeof value !== 'string')
+        return nestedRecord(value);
+    try {
+        return nestedRecord(JSON.parse(value));
+    }
+    catch {
+        return {};
+    }
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function statusValue(record) {
+    const candidate = record.statusCode ?? record.status;
+    return typeof candidate === 'number' && Number.isInteger(candidate) ? candidate : null;
+}
+function providerCode(record) {
+    const data = nestedRecord(record.data);
+    const dataError = nestedRecord(data.error);
+    const responseBody = jsonRecord(record.responseBody);
+    const responseError = nestedRecord(responseBody.error);
+    return stringValue(record.code)
+        ?? stringValue(data.code)
+        ?? stringValue(dataError.code)
+        ?? stringValue(responseError.code);
+}
+function providerMessage(record) {
+    const data = nestedRecord(record.data);
+    const dataError = nestedRecord(data.error);
+    const responseBody = jsonRecord(record.responseBody);
+    const responseError = nestedRecord(responseBody.error);
+    const raw = stringValue(dataError.message)
+        ?? stringValue(responseError.message)
+        ?? stringValue(data.message)
+        ?? stringValue(responseBody.message)
+        ?? stringValue(record.message);
+    if (!raw)
+        return null;
+    return raw
+        .replace(/(?:sk-|key-|token-)[a-z0-9_-]{8,}/gi, '[已隐藏]')
+        .replace(/\s+/g, ' ')
+        .slice(0, 500);
+}
+function isTimeoutError(records, code) {
+    if (['ETIMEDOUT', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT']
+        .includes(code.toUpperCase()))
+        return true;
+    return records.some((record) => {
+        const name = stringValue(record.name)?.toLowerCase() ?? '';
+        const message = stringValue(record.message)?.toLowerCase() ?? '';
+        return name.includes('timeout') || /(?:timed?\s*out|timeout|deadline exceeded)/i.test(message);
+    });
+}
+function isContentFilterError(code, records) {
+    const haystack = [code, ...records.map((record) => providerMessage(record) ?? '')]
+        .join(' ')
+        .toLowerCase();
+    return /content[_\s-]?(?:filter|policy)|moderation|safety[_\s-]?(?:filter|policy)|sensitive[_\s-]?content/.test(haystack);
+}
+function categoryFor(status, code, records) {
+    const normalizedCode = code.toLowerCase();
+    if (records.some((record) => stringValue(record.name) === 'AbortError'))
+        return 'cancelled';
+    if (normalizedCode.includes('context_length') || normalizedCode.includes('context_window')) {
+        return 'context_overflow';
+    }
+    if (isContentFilterError(code, records))
+        return 'content_filter';
+    if (normalizedCode === 'provider_network_error')
+        return 'network';
+    if (status === 401 || status === 403)
+        return 'authentication';
+    if (status === 402 || normalizedCode.includes('billing'))
+        return 'billing';
+    if (status === 429 && normalizedCode.includes('quota'))
+        return 'quota';
+    if (status === 429)
+        return 'rate_limit';
+    if (status === 498)
+        return 'server';
+    if (status === 499)
+        return 'cancelled';
+    if (status !== null && status >= 500)
+        return 'server';
+    if (status === 400 || status === 404 || status === 405 || status === 413 || status === 422) {
+        return 'invalid_request';
+    }
+    if (isTimeoutError(records, code) || NETWORK_ERROR_CODES.has(code.toUpperCase()))
+        return 'network';
+    if (records.some((record) => record.isRetryable === true))
+        return 'network';
+    return 'unknown';
+}
+function headerValue(headers, name) {
+    if (headers instanceof Headers)
+        return headers.get(name);
+    if (!headers || typeof headers !== 'object')
+        return null;
+    const match = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
+    return match ? String(match[1]) : null;
+}
+function retryAfterMs(record) {
+    const raw = headerValue(record.responseHeaders ?? record.headers, 'retry-after');
+    if (!raw)
+        return null;
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.round(seconds * 1_000);
+    const timestamp = Date.parse(raw);
+    return Number.isFinite(timestamp) ? Math.max(0, timestamp - Date.now()) : null;
+}
+function safeMessage(category, detail = null) {
+    const messages = {
+        network: '模型供应商网络请求失败',
+        rate_limit: '模型供应商请求频率受限',
+        server: '模型供应商服务暂时不可用',
+        quota: '模型供应商额度不足',
+        billing: '模型供应商计费状态异常',
+        authentication: '模型供应商鉴权失败',
+        invalid_request: '模型供应商拒绝了请求参数',
+        context_overflow: '模型上下文超过供应商限制',
+        content_filter: '模型供应商拒绝了受限内容',
+        cancelled: '模型请求已取消',
+        unknown: '模型供应商请求失败',
+    };
+    const summary = messages[category];
+    return category === 'invalid_request' && detail ? `${summary}：${detail}` : summary;
+}
+export function normalizeProviderError(input, error) {
+    if (error instanceof ProviderModelStepError)
+        return error;
+    const records = errorChain(error);
+    const status = records.map(statusValue).find((value) => value !== null) ?? null;
+    const reportedCode = records.map(providerCode).find((value) => value !== null) ?? null;
+    const timeout = isTimeoutError(records, reportedCode ?? '');
+    const code = reportedCode ?? (timeout ? 'MODEL_REQUEST_TIMEOUT' : 'PROVIDER_ERROR');
+    const category = categoryFor(status, code, records);
+    const detail = records.map(providerMessage).find((value) => value !== null) ?? null;
+    return new ProviderModelStepError({
+        code,
+        category,
+        status,
+        retryable: ['network', 'rate_limit', 'server'].includes(category),
+        retryAfterMs: records.map(retryAfterMs).find((value) => value !== null) ?? null,
+        providerId: input.providerId,
+        modelId: input.modelId,
+        requestId: input.requestId,
+        message: safeMessage(category, detail),
+    }, { cause: error });
+}
+export function createCredentialError(input) {
+    return new ProviderModelStepError({
+        code: 'API_KEY_MISSING', category: 'authentication', status: null, retryable: false,
+        retryAfterMs: null, providerId: input.providerId, modelId: input.modelId,
+        requestId: input.requestId, message: '模型供应商凭据未配置',
+    });
+}
+export function createCancelledError(input) {
+    return new ProviderModelStepError({
+        code: 'MODEL_STEP_CANCELLED', category: 'cancelled', status: null, retryable: false,
+        retryAfterMs: null, providerId: input.providerId, modelId: input.modelId,
+        requestId: input.requestId, message: '模型请求已取消',
+    });
+}
+export function isAgentSemanticRetryable(error) {
+    return readPortableRetry(error);
+}

package/dist/runtime/errors.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export { AiRuntimeError, cancelledError } from './AiRuntimeError.js';
+export { parseModelProviderError, ProviderModelStepError, serializeModelProviderError, } from './provider-error-core.js';
+export type { ModelProviderError, ModelProviderErrorCategory, ProviderErrorContext, } from './provider-error-core.js';
+export declare const modelProviderErrorCategorySchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    network: "network";
+    rate_limit: "rate_limit";
+    server: "server";
+    quota: "quota";
+    billing: "billing";
+    authentication: "authentication";
+    invalid_request: "invalid_request";
+    context_overflow: "context_overflow";
+    content_filter: "content_filter";
+    unknown: "unknown";
+}>;
+export declare const modelProviderErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    category: z.ZodEnum<{
+        cancelled: "cancelled";
+        network: "network";
+        rate_limit: "rate_limit";
+        server: "server";
+        quota: "quota";
+        billing: "billing";
+        authentication: "authentication";
+        invalid_request: "invalid_request";
+        context_overflow: "context_overflow";
+        content_filter: "content_filter";
+        unknown: "unknown";
+    }>;
+    status: z.ZodNullable<z.ZodNumber>;
+    retryable: z.ZodBoolean;
+    retryAfterMs: z.ZodNullable<z.ZodNumber>;
+    providerId: z.ZodString;
+    modelId: z.ZodString;
+    requestId: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strict>;

package/dist/runtime/errors.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export { AiRuntimeError, cancelledError } from './AiRuntimeError.js';
+export { parseModelProviderError, ProviderModelStepError, serializeModelProviderError, } from './provider-error-core.js';
+export const modelProviderErrorCategorySchema = z.enum([
+    'network',
+    'rate_limit',
+    'server',
+    'quota',
+    'billing',
+    'authentication',
+    'invalid_request',
+    'context_overflow',
+    'content_filter',
+    'cancelled',
+    'unknown',
+]);
+export const modelProviderErrorSchema = z.object({
+    code: z.string().min(1).max(200),
+    category: modelProviderErrorCategorySchema,
+    status: z.number().int().min(100).max(599).nullable(),
+    retryable: z.boolean(),
+    retryAfterMs: z.number().int().nonnegative().nullable(),
+    providerId: z.string().min(1),
+    modelId: z.string().min(1),
+    requestId: z.string().min(1),
+    message: z.string().min(1).max(1_000),
+}).strict();

package/dist/runtime/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 运行时契约层：SDK 与宿主环境之间的全部接口，以及零依赖的纯内存任务登记表。
+ *
+ * 本目录定义「供应商适配逻辑需要宿主提供什么」，不含任何具体实现——具体实现由每个
+ * 宿主自行提供并组装成 {@link RuntimeContext}（Electron 侧实现见
+ * `electron/main/services/ai-runtime/sdk-runtime.ts`）。
+ */
+export { modelProviderErrorCategorySchema, modelProviderErrorSchema, parseModelProviderError, ProviderModelStepError, serializeModelProviderError, } from './errors.js';
+export { AiRuntimeError, cancelledError } from './AiRuntimeError.js';
+export type { ModelProviderError, ModelProviderErrorCategory, ProviderErrorContext, } from './errors.js';
+export { createCancelledError, createCredentialError, isAgentSemanticRetryable, normalizeProviderError, } from './error-classify.js';
+export { describeNetworkFailure, shouldRetry } from './retry.js';
+export type { NetworkFailure, RetryMode } from './retry.js';
+export type { Transport } from './Transport.js';
+export type { RealtimeConnectOptions, RealtimeConnection, RealtimeMessage, RealtimePayload, RealtimeTransport, } from './RealtimeTransport.js';
+export { resolveRuntimeContext } from './RuntimeContext.js';
+export type { ResolvedRuntimeContext, RuntimeContext } from './RuntimeContext.js';
+export type { CredentialScope, CredentialStore } from './CredentialStore.js';
+export type { MediaBinary, MediaReader } from './MediaReader.js';
+export type { LogContext, Logger } from './Logger.js';
+export { noopLogger } from './Logger.js';
+export type { TraceSpan, Tracer } from './Tracer.js';
+export { noopTracer } from './Tracer.js';
+export { cancelTask, clearCancelFlag, isCancelled, registerAbortController, } from './task-registry.js';
+export type { TaskNamespace } from './task-registry.js';

package/dist/runtime/index.js

@@ -0,0 +1,15 @@
+/**
+ * 运行时契约层：SDK 与宿主环境之间的全部接口，以及零依赖的纯内存任务登记表。
+ *
+ * 本目录定义「供应商适配逻辑需要宿主提供什么」，不含任何具体实现——具体实现由每个
+ * 宿主自行提供并组装成 {@link RuntimeContext}（Electron 侧实现见
+ * `electron/main/services/ai-runtime/sdk-runtime.ts`）。
+ */
+export { modelProviderErrorCategorySchema, modelProviderErrorSchema, parseModelProviderError, ProviderModelStepError, serializeModelProviderError, } from './errors.js';
+export { AiRuntimeError, cancelledError } from './AiRuntimeError.js';
+export { createCancelledError, createCredentialError, isAgentSemanticRetryable, normalizeProviderError, } from './error-classify.js';
+export { describeNetworkFailure, shouldRetry } from './retry.js';
+export { resolveRuntimeContext } from './RuntimeContext.js';
+export { noopLogger } from './Logger.js';
+export { noopTracer } from './Tracer.js';
+export { cancelTask, clearCancelFlag, isCancelled, registerAbortController, } from './task-registry.js';

package/dist/runtime/provider-error-core.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 不依赖 schema 库的供应商错误值与序列化内核。
+ *
+ * UXP 的原生 LLM 流式入口只需要稳定错误协议，不能因此把 Zod 的 JIT 实现带进 bundle。
+ * `errors.ts` 继续在兼容入口导出 Zod schema；两条路径共用这里唯一的错误类与 wire format。
+ */
+export type ModelProviderErrorCategory = 'network' | 'rate_limit' | 'server' | 'quota' | 'billing' | 'authentication' | 'invalid_request' | 'context_overflow' | 'content_filter' | 'cancelled' | 'unknown';
+export interface ModelProviderError {
+    code: string;
+    category: ModelProviderErrorCategory;
+    status: number | null;
+    retryable: boolean;
+    retryAfterMs: number | null;
+    providerId: string;
+    modelId: string;
+    requestId: string;
+    message: string;
+}
+export interface ProviderErrorContext {
+    providerId: string;
+    modelId: string;
+    requestId: string;
+}
+export declare function serializeModelProviderError(error: ModelProviderError): string;
+export declare function parseModelProviderError(value: unknown): ModelProviderError | null;
+export declare class ProviderModelStepError extends Error {
+    readonly details: ModelProviderError;
+    readonly code: string;
+    readonly category: ModelProviderErrorCategory;
+    constructor(details: ModelProviderError, options?: {
+        cause?: unknown;
+    });
+}

package/dist/runtime/provider-error-core.js

@@ -0,0 +1,86 @@
+const ERROR_MARKER = '[provider_error]';
+const CATEGORIES = new Set([
+    'network',
+    'rate_limit',
+    'server',
+    'quota',
+    'billing',
+    'authentication',
+    'invalid_request',
+    'context_overflow',
+    'content_filter',
+    'cancelled',
+    'unknown',
+]);
+function isNonEmptyString(value, maxLength) {
+    return typeof value === 'string' && value.length > 0 && (maxLength === undefined || value.length <= maxLength);
+}
+function isNullableInteger(value, minimum, maximum) {
+    return value === null || (typeof value === 'number'
+        && Number.isInteger(value)
+        && value >= minimum
+        && (maximum === undefined || value <= maximum));
+}
+function parseDetails(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const details = value;
+    if (!isNonEmptyString(details.code, 200))
+        return null;
+    if (typeof details.category !== 'string' || !CATEGORIES.has(details.category))
+        return null;
+    if (!isNullableInteger(details.status, 100, 599))
+        return null;
+    if (typeof details.retryable !== 'boolean')
+        return null;
+    if (!isNullableInteger(details.retryAfterMs, 0))
+        return null;
+    if (!isNonEmptyString(details.providerId))
+        return null;
+    if (!isNonEmptyString(details.modelId))
+        return null;
+    if (!isNonEmptyString(details.requestId))
+        return null;
+    if (!isNonEmptyString(details.message, 1_000))
+        return null;
+    if (Object.keys(details).some((key) => ![
+        'code', 'category', 'status', 'retryable', 'retryAfterMs',
+        'providerId', 'modelId', 'requestId', 'message',
+    ].includes(key)))
+        return null;
+    return details;
+}
+function requireDetails(value) {
+    const details = parseDetails(value);
+    if (!details)
+        throw new Error('Invalid model provider error details');
+    return details;
+}
+export function serializeModelProviderError(error) {
+    return `${ERROR_MARKER}${JSON.stringify(requireDetails(error))}`;
+}
+export function parseModelProviderError(value) {
+    const message = value instanceof Error ? value.message : typeof value === 'string' ? value : '';
+    const markerIndex = message.indexOf(ERROR_MARKER);
+    if (markerIndex < 0)
+        return null;
+    try {
+        return parseDetails(JSON.parse(message.slice(markerIndex + ERROR_MARKER.length)));
+    }
+    catch {
+        return null;
+    }
+}
+export class ProviderModelStepError extends Error {
+    details;
+    code;
+    category;
+    constructor(details, options) {
+        const validated = requireDetails(details);
+        super(serializeModelProviderError(validated), options);
+        this.name = 'ProviderModelStepError';
+        this.details = validated;
+        this.code = validated.code;
+        this.category = validated.category;
+    }
+}

package/dist/runtime/retry.d.ts

@@ -0,0 +1,7 @@
+export type RetryMode = 'safe-preconnect' | 'request' | 'poll-query';
+export interface NetworkFailure {
+    code: string;
+    message: string;
+}
+export declare function describeNetworkFailure(error: unknown): NetworkFailure;
+export declare function shouldRetry(error: unknown, mode?: RetryMode): boolean;

package/dist/runtime/retry.js

@@ -0,0 +1,72 @@
+import { AiRuntimeError } from './AiRuntimeError.js';
+const SAFE_PRECONNECT_RETRY_CODES = new Set([
+    'UND_ERR_CONNECT_TIMEOUT',
+    'ENETUNREACH',
+    'EAI_AGAIN',
+    'ENOTFOUND',
+    'ECONNREFUSED',
+]);
+function errorChain(error) {
+    const records = [];
+    const seen = new Set();
+    let current = error;
+    while (current && typeof current === 'object' && records.length < 4 && !seen.has(current)) {
+        seen.add(current);
+        const record = current;
+        records.push(record);
+        current = record.cause;
+    }
+    return records;
+}
+function providerCode(record) {
+    for (const key of ['code', 'errorCode', 'type']) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+export function describeNetworkFailure(error) {
+    const records = errorChain(error);
+    const code = records.map(providerCode).find((value) => value !== null)
+        ?? (error instanceof Error ? error.name : 'UNKNOWN_NETWORK_ERROR');
+    const message = records.map((record) => record.message).find((value) => typeof value === 'string' && value.trim().length > 0) ?? (error instanceof Error ? error.message : String(error));
+    return { code, message };
+}
+export function shouldRetry(error, mode = 'request') {
+    if (mode === 'safe-preconnect') {
+        return SAFE_PRECONNECT_RETRY_CODES.has(describeNetworkFailure(error).code.toUpperCase());
+    }
+    const structuredRetryable = readStructuredRetryable(error);
+    if (structuredRetryable !== undefined)
+        return structuredRetryable;
+    if (error instanceof AiRuntimeError) {
+        if (mode === 'poll-query') {
+            return !['provider_task_failed', 'cancelled', 'invalid_endpoint'].includes(error.code);
+        }
+        return ['provider_network_error', 'provider_http_error'].includes(error.code);
+    }
+    return true;
+}
+function readStructuredRetryable(error) {
+    if (error && typeof error === 'object') {
+        const details = error.details;
+        if (details && typeof details === 'object' && typeof details.retryable === 'boolean') {
+            return details.retryable;
+        }
+    }
+    const message = error instanceof Error ? error.message : typeof error === 'string' ? error : '';
+    const marker = '[provider_error]';
+    const markerIndex = message.indexOf(marker);
+    if (markerIndex < 0)
+        return undefined;
+    try {
+        const parsed = JSON.parse(message.slice(markerIndex + marker.length));
+        return parsed && typeof parsed === 'object' && typeof parsed.retryable === 'boolean'
+            ? parsed.retryable
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/runtime/task-registry.d.ts

@@ -0,0 +1,5 @@
+export type TaskNamespace = 'generation' | 'llm' | (string & {});
+export declare function clearCancelFlag(namespace: TaskNamespace, taskId: string): void;
+export declare function registerAbortController(namespace: TaskNamespace, taskId: string, controller: AbortController): void;
+export declare function cancelTask(namespace: TaskNamespace, taskId: string): void;
+export declare function isCancelled(namespace: TaskNamespace, taskId: string): boolean;

package/dist/runtime/task-registry.js

@@ -0,0 +1,25 @@
+const cancelledTasks = new Set();
+const abortControllers = new Map();
+function taskKey(namespace, taskId) {
+    return `${namespace}:${taskId}`;
+}
+export function clearCancelFlag(namespace, taskId) {
+    const key = taskKey(namespace, taskId);
+    cancelledTasks.delete(key);
+    abortControllers.delete(key);
+}
+export function registerAbortController(namespace, taskId, controller) {
+    abortControllers.set(taskKey(namespace, taskId), controller);
+}
+export function cancelTask(namespace, taskId) {
+    const normalized = taskId.trim();
+    if (!normalized) {
+        return;
+    }
+    const key = taskKey(namespace, normalized);
+    cancelledTasks.add(key);
+    abortControllers.get(key)?.abort();
+}
+export function isCancelled(namespace, taskId) {
+    return cancelledTasks.has(taskKey(namespace, taskId));
+}

package/dist/structured-output/index.d.ts

@@ -0,0 +1 @@
+export * from './seedream-layer-stack.js';

package/dist/structured-output/index.js

@@ -0,0 +1 @@
+export * from './seedream-layer-stack.js';

package/dist/structured-output/seedream-layer-stack.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue, StructuredGenerationLayerStackV1 } from '../types/runtime.js';
+type SeedreamLayerProvider = 'volcengine' | 'apimart' | 'kie';
+export declare function parseSeedreamLayerStack(provider: SeedreamLayerProvider, metadata: JsonValue): StructuredGenerationLayerStackV1;
+export {};