@henjicc/ai-sdk 0.2.8

package/dist/providers/apimart.js

@@ -0,0 +1,128 @@
+import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+import { POLL_QUERY_FAILED, pollUntilResult } from '../protocols/polling.js';
+import { buildApiMartEndpoints, markApiMartEndpointReachable } from './endpoints/apimart.js';
+import { collectDeepUrls, getPointer, isJsonObject, readJsonResponse, stringAt } from './helpers.js';
+import { fetchProvider } from './provider-fetch.js';
+const RESPONSE_VERSION = '2026-07-27';
+export async function execute(input) {
+    const payload = await sendCreateTask(input);
+    const taskId = extractTaskId(payload);
+    const urls = extractUrls(payload);
+    if (urls.length > 0 && !taskId) {
+        return { status: 'completed', url: urls.join('|||'), metadata: payload };
+    }
+    if (!taskId) {
+        throw new AiRuntimeError('empty_result', 'APIMart response has neither task ID nor media URL');
+    }
+    return { status: 'pending', url: '', taskId, metadata: payload };
+}
+export async function continuePolling(input) {
+    const payload = await pollTask(input);
+    const urls = extractUrls(payload);
+    if (urls.length === 0) {
+        throw new AiRuntimeError('empty_result', `APIMart response has no media URL (task_id=${input.taskId})`);
+    }
+    return { status: 'completed', url: urls.join('|||'), taskId: input.taskId, metadata: payload };
+}
+async function sendCreateTask(input) {
+    const endpoints = buildApiMartEndpoints(input.route);
+    const response = await fetchProvider('APIMart', endpoints[0], {
+        method: input.method,
+        headers: {
+            Authorization: `Bearer ${input.apiKey}`,
+            'Content-Type': 'application/json',
+            'Idempotency-Key': input.requestId,
+            'X-APIMart-Response-Version': RESPONSE_VERSION,
+        },
+        // APIMart 全供应商统一关闭平台预审。这里在最终发送边界强制覆盖，
+        // 防止当前或未来模型漏写、误写 nsfw_check。
+        body: JSON.stringify(isJsonObject(input.body)
+            ? { ...input.body, nsfw_check: false }
+            : input.body),
+        signal: input.signal,
+    }, {
+        transport: input.runtime.transport,
+        // 仅在能证明尚未建立连接时切换官方大陆备用线路，避免扩大重放范围。
+        retryPreconnectOnce: true,
+        fallbackEndpoints: endpoints.slice(1),
+        onEndpointReached: markApiMartEndpointReachable,
+    });
+    const payload = await readJsonResponse(response, 'APIMart');
+    assertPayloadSucceeded(payload, 'APIMart create task failed');
+    return payload;
+}
+async function pollTask(input) {
+    return await pollUntilResult(input, async () => {
+        const endpoints = buildApiMartEndpoints(`/v1/tasks/${encodeURIComponent(input.taskId)}`);
+        const response = await fetchProvider('APIMart', endpoints[0], {
+            headers: {
+                Authorization: `Bearer ${input.apiKey}`,
+                'X-APIMart-Response-Version': RESPONSE_VERSION,
+            },
+            signal: input.signal,
+        }, {
+            transport: input.runtime.transport,
+            retryPreconnectOnce: true,
+            fallbackEndpoints: endpoints.slice(1),
+            onEndpointReached: markApiMartEndpointReachable,
+        });
+        const payload = await readJsonResponse(response, 'APIMart');
+        const status = extractStatus(payload);
+        if (['completed', 'succeeded', 'success'].includes(status))
+            return payload;
+        if (['failed', 'error', 'canceled', 'cancelled'].includes(status)) {
+            throw new AiRuntimeError('provider_task_failed', extractErrorMessage(payload) ?? 'APIMart task failed');
+        }
+        if (!status)
+            return POLL_QUERY_FAILED;
+        return undefined;
+    });
+}
+function assertPayloadSucceeded(payload, fallback) {
+    const status = extractStatus(payload);
+    if (['failed', 'error', 'canceled', 'cancelled'].includes(status)) {
+        throw new AiRuntimeError('provider_task_failed', extractErrorMessage(payload) ?? fallback);
+    }
+}
+function extractTaskId(payload) {
+    for (const pointer of ['/data/id', '/data/task_id', '/data/taskId', '/data/0/task_id', '/task_id', '/taskId', '/id']) {
+        const taskId = stringAt(payload, pointer);
+        if (taskId?.trim())
+            return taskId;
+    }
+    return undefined;
+}
+function extractStatus(payload) {
+    for (const pointer of ['/data/status', '/data/state', '/data/0/status', '/status', '/state']) {
+        const status = stringAt(payload, pointer);
+        if (status)
+            return status.trim().toLowerCase();
+    }
+    return '';
+}
+function extractErrorMessage(payload) {
+    for (const pointer of ['/data/error/message', '/error/message', '/data/error', '/error', '/message']) {
+        const message = stringAt(payload, pointer);
+        if (message?.trim())
+            return message;
+    }
+    return undefined;
+}
+function extractUrls(payload) {
+    const urls = [];
+    for (const pointer of [
+        '/data/result/images',
+        '/data/result/videos',
+        '/result/images',
+        '/result/videos',
+        '/data/images',
+        '/data/videos',
+    ]) {
+        const value = getPointer(payload, pointer);
+        if (value !== undefined)
+            collectDeepUrls(value, urls);
+    }
+    if (urls.length === 0)
+        collectDeepUrls(payload, urls);
+    return urls;
+}

package/dist/providers/bailian.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderContinuePollingInput, ProviderExecutionInput, ProviderExecutionResult } from '../types/runtime.js';
+export declare function execute(input: ProviderExecutionInput): Promise<ProviderExecutionResult>;
+export declare function continuePolling(_input: ProviderContinuePollingInput): Promise<ProviderExecutionResult>;

package/dist/providers/bailian.js

@@ -0,0 +1,50 @@
+import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+import { isJsonObject, normalizeEndpoint, pushUniqueUrl, readJsonResponse, stringAt } from './helpers.js';
+import { fetchProvider } from './provider-fetch.js';
+const BAILIAN_BASE_URL = 'https://dashscope.aliyuncs.com';
+export async function execute(input) {
+    const response = await fetchProvider('Bailian', normalizeEndpoint(BAILIAN_BASE_URL, input.route), {
+        method: input.method,
+        headers: {
+            Authorization: `Bearer ${input.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(input.body),
+        signal: input.signal,
+    }, {
+        transport: input.runtime.transport,
+        retryPreconnectOnce: true,
+    });
+    const payload = await readJsonResponse(response, 'Bailian');
+    const errorCode = stringAt(payload, '/code');
+    if (errorCode) {
+        throw new AiRuntimeError('provider_task_failed', stringAt(payload, '/message') ?? errorCode);
+    }
+    const urls = extractImageUrls(payload);
+    if (urls.length === 0) {
+        throw new AiRuntimeError('empty_result', 'Bailian response has no image URL');
+    }
+    return { status: 'completed', url: urls.join('|||'), metadata: payload };
+}
+export async function continuePolling(_input) {
+    throw new AiRuntimeError('unsupported_provider', 'Bailian official image models use synchronous generation');
+}
+function extractImageUrls(value) {
+    const urls = [];
+    const visit = (item) => {
+        if (Array.isArray(item)) {
+            item.forEach(visit);
+            return;
+        }
+        if (!isJsonObject(item))
+            return;
+        for (const [key, child] of Object.entries(item)) {
+            if ((key === 'image' || key === 'url') && typeof child === 'string' && /^https?:\/\//.test(child)) {
+                pushUniqueUrl(urls, child);
+            }
+            visit(child);
+        }
+    };
+    visit(value);
+    return urls;
+}

package/dist/providers/connection.d.ts

@@ -0,0 +1,3 @@
+import { type RuntimeContext } from '../runtime/RuntimeContext.js';
+import type { ProviderConnectionTestResultDto } from '../types/runtime.js';
+export declare function testProviderConnection(providerId: string, runtimeContext: RuntimeContext): Promise<ProviderConnectionTestResultDto>;

package/dist/providers/connection.js

@@ -0,0 +1,169 @@
+import { resolveRuntimeContext } from '../runtime/RuntimeContext.js';
+import { buildApiMartEndpoints, markApiMartEndpointReachable } from './endpoints/apimart.js';
+import { fetchProvider } from './provider-fetch.js';
+const CONNECTION_TIMEOUT_MS = 12_000;
+// Grsai 暂未加入探测表：其余额接口 `POST /client/openapi/getAPIKeyCredits` 用 POST（这里统一是 GET），
+// 且鉴权走 Authorization Bearer 还是账户 token 字段官方文档没写清楚，接入前需登录控制台核实，
+// 详见 packages/ai-sdk/docs/model-adaptation/供应商/Grsai.md §5.2。宁可保持"已保存未校验"，也不要拿一个不确定的契约去误判用户 Key 状态。
+const PROVIDER_PROBES = {
+    kie: {
+        endpoints: () => ['https://api.kie.ai/api/v1/chat/credit'],
+        authorizationPrefix: 'Bearer',
+        kind: 'kie_balance',
+    },
+    apimart: {
+        endpoints: () => buildApiMartEndpoints('/v1/balance'),
+        authorizationPrefix: 'Bearer',
+        kind: 'apimart_balance',
+    },
+    ppio: {
+        endpoints: () => ['https://api.ppio.com/openai/v1/models'],
+        authorizationPrefix: 'Bearer',
+        kind: 'model_catalog',
+    },
+};
+function result(providerId, startedAt, status, extra = {}) {
+    return {
+        providerId,
+        status,
+        verified: status === 'connected' || status === 'insufficient_balance' || status === 'rate_limited',
+        checkedAt: new Date().toISOString(),
+        durationMs: Math.max(0, Date.now() - startedAt),
+        ...extra,
+    };
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function numberField(value, key) {
+    const field = value?.[key];
+    return typeof field === 'number' && Number.isFinite(field) ? field : undefined;
+}
+function stringField(value, key) {
+    const field = value?.[key];
+    return typeof field === 'string' ? field.trim().toLowerCase() : '';
+}
+async function readResponsePayload(response) {
+    try {
+        return record(await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+function classifyHttpStatus(status) {
+    if (status === 401 || status === 403)
+        return 'invalid_key';
+    if (status === 402)
+        return 'insufficient_balance';
+    if (status === 429)
+        return 'rate_limited';
+    if (status >= 500)
+        return 'service_error';
+    return null;
+}
+function classifyKie(providerId, startedAt, response, payload) {
+    const payloadCode = numberField(payload, 'code');
+    const status = payloadCode ? classifyHttpStatus(payloadCode) : classifyHttpStatus(response.status);
+    if (status)
+        return result(providerId, startedAt, status, { httpStatus: response.status });
+    if (response.ok && payloadCode === 200) {
+        return result(providerId, startedAt, 'connected', {
+            httpStatus: response.status,
+            remainingBalance: numberField(payload, 'data'),
+            balanceUnit: 'credits',
+        });
+    }
+    return result(providerId, startedAt, 'service_error', { httpStatus: response.status });
+}
+function classifyApiMart(providerId, startedAt, response, payload) {
+    const httpStatus = classifyHttpStatus(response.status);
+    if (httpStatus)
+        return result(providerId, startedAt, httpStatus, { httpStatus: response.status });
+    if (response.ok && payload?.success === true) {
+        return result(providerId, startedAt, 'connected', {
+            httpStatus: response.status,
+            remainingBalance: numberField(payload, 'remain_balance'),
+            balanceUnit: 'provider_units',
+            unlimitedBalance: payload.unlimited_quota === true,
+        });
+    }
+    const message = stringField(payload, 'message');
+    if (response.ok && (message.includes('token') || message.includes('auth'))) {
+        return result(providerId, startedAt, 'invalid_key', { httpStatus: response.status });
+    }
+    return result(providerId, startedAt, 'service_error', { httpStatus: response.status });
+}
+function classifyCatalog(providerId, startedAt, response) {
+    const status = classifyHttpStatus(response.status);
+    if (status)
+        return result(providerId, startedAt, status, { httpStatus: response.status });
+    return result(providerId, startedAt, response.ok ? 'connected' : 'service_error', {
+        httpStatus: response.status,
+    });
+}
+export async function testProviderConnection(providerId, runtimeContext) {
+    const { transport, credentials, logger } = resolveRuntimeContext(runtimeContext);
+    const startedAt = Date.now();
+    const apiKey = await credentials.get('generation', providerId);
+    if (!apiKey)
+        return result(providerId, startedAt, 'not_configured');
+    const probe = PROVIDER_PROBES[providerId];
+    if (!probe)
+        return result(providerId, startedAt, 'saved_unverified');
+    logger.info('供应商连接检测开始', {
+        event: 'provider_connection.test.start',
+        providerId,
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), CONNECTION_TIMEOUT_MS);
+    try {
+        const [endpoint, ...fallbackEndpoints] = probe.endpoints();
+        const response = await fetchProvider(providerId, endpoint, {
+            method: 'GET',
+            headers: {
+                Authorization: `${probe.authorizationPrefix} ${apiKey}`,
+                Accept: 'application/json',
+            },
+            signal: controller.signal,
+        }, {
+            transport,
+            retryPreconnectOnce: true,
+            fallbackEndpoints,
+            onEndpointReached: probe.kind === 'apimart_balance' ? markApiMartEndpointReachable : undefined,
+        });
+        const payload = probe.kind === 'model_catalog' ? null : await readResponsePayload(response);
+        const tested = probe.kind === 'kie_balance'
+            ? classifyKie(providerId, startedAt, response, payload)
+            : probe.kind === 'apimart_balance'
+                ? classifyApiMart(providerId, startedAt, response, payload)
+                : classifyCatalog(providerId, startedAt, response);
+        logger.info('供应商连接检测完成', {
+            event: 'provider_connection.test.completed',
+            providerId,
+            context: {
+                status: tested.status,
+                verified: tested.verified,
+                httpStatus: tested.httpStatus,
+                durationMs: tested.durationMs,
+            },
+        });
+        return tested;
+    }
+    catch (error) {
+        const status = controller.signal.aborted ? 'timeout' : 'network_error';
+        const tested = result(providerId, startedAt, status);
+        logger.warn('供应商连接检测失败', {
+            event: 'provider_connection.test.failed',
+            providerId,
+            context: { status, durationMs: tested.durationMs },
+            error,
+        });
+        return tested;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/providers/endpoints/apimart.d.ts

@@ -0,0 +1,11 @@
+import type { Transport } from '../../runtime/Transport.js';
+export declare const APIMART_API_BASE_URLS: readonly ["https://api.apimart.ai", "https://api.apib.ai", "https://api.aiuxu.com", "https://api.aishuch.com"];
+export declare function buildApiMartEndpoints(route: string): string[];
+/** 把某个成功响应过的完整 endpoint URL 记为本进程后续请求的优先域名。 */
+export declare function markApiMartEndpointReachable(endpoint: string): void;
+export declare function resetApiMartEndpointPreference(): void;
+/**
+ * 应用启动后台探测：按默认顺序找出第一个当前网络下可达的域名并预热为优先域名，
+ * 让用户首次真实生成请求不必先撞一次必然失败的默认线路。不阻塞启动、探测失败静默忽略。
+ */
+export declare function warmApiMartEndpointPreference(transport: Transport): Promise<void>;

package/dist/providers/endpoints/apimart.js

@@ -0,0 +1,49 @@
+export const APIMART_API_BASE_URLS = [
+    'https://api.apimart.ai',
+    'https://api.apib.ai',
+    'https://api.aiuxu.com',
+    'https://api.aishuch.com',
+];
+const WARMUP_TIMEOUT_MS = 4_000;
+// 进程内存缓存：记录"当前网络环境下已证明可达"的域名，优先排到请求顺序最前面。
+// 不做地理位置判断，只认连通性；不持久化，应用重启后清空重新判断，网络环境变化能自愈。
+let preferredBaseUrl;
+function orderedBaseUrls() {
+    if (!preferredBaseUrl || preferredBaseUrl === APIMART_API_BASE_URLS[0])
+        return APIMART_API_BASE_URLS;
+    return [preferredBaseUrl, ...APIMART_API_BASE_URLS.filter((baseUrl) => baseUrl !== preferredBaseUrl)];
+}
+export function buildApiMartEndpoints(route) {
+    const normalizedRoute = route.startsWith('/') ? route : `/${route}`;
+    return orderedBaseUrls().map((baseUrl) => `${baseUrl}${normalizedRoute}`);
+}
+/** 把某个成功响应过的完整 endpoint URL 记为本进程后续请求的优先域名。 */
+export function markApiMartEndpointReachable(endpoint) {
+    const matched = APIMART_API_BASE_URLS.find((baseUrl) => endpoint.startsWith(baseUrl));
+    if (matched)
+        preferredBaseUrl = matched;
+}
+export function resetApiMartEndpointPreference() {
+    preferredBaseUrl = undefined;
+}
+/**
+ * 应用启动后台探测：按默认顺序找出第一个当前网络下可达的域名并预热为优先域名，
+ * 让用户首次真实生成请求不必先撞一次必然失败的默认线路。不阻塞启动、探测失败静默忽略。
+ */
+export async function warmApiMartEndpointPreference(transport) {
+    for (const baseUrl of APIMART_API_BASE_URLS) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), WARMUP_TIMEOUT_MS);
+        try {
+            await transport.fetch(`${baseUrl}/v1/balance`, { method: 'GET', signal: controller.signal });
+            preferredBaseUrl = baseUrl;
+            return;
+        }
+        catch {
+            continue;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/providers/endpoints/grsai.d.ts

@@ -0,0 +1,11 @@
+import type { Transport } from '../../runtime/Transport.js';
+export declare const GRSAI_API_BASE_URLS: readonly ["https://grsaiapi.com", "https://grsai.dakka.com.cn"];
+export declare function buildGrsaiEndpoints(route: string): string[];
+/** 把某个成功响应过的完整 endpoint URL 记为本进程后续请求的优先域名。 */
+export declare function markGrsaiEndpointReachable(endpoint: string): void;
+export declare function resetGrsaiEndpointPreference(): void;
+/**
+ * 应用启动后台探测：按默认顺序找出第一个当前网络下可达的域名并预热为优先域名，
+ * 让用户首次真实生成请求不必先撞一次必然失败的默认线路。不阻塞启动、探测失败静默忽略。
+ */
+export declare function warmGrsaiEndpointPreference(transport: Transport): Promise<void>;

package/dist/providers/endpoints/grsai.js

@@ -0,0 +1,50 @@
+export const GRSAI_API_BASE_URLS = [
+    'https://grsaiapi.com',
+    'https://grsai.dakka.com.cn',
+];
+const WARMUP_TIMEOUT_MS = 4_000;
+// 进程内存缓存：记录"当前网络环境下已证明可达"的域名，优先排到请求顺序最前面。
+// 不做地理位置判断，只认连通性；不持久化，应用重启后清空重新判断，网络环境变化能自愈。
+// 两条线路（全球节点 / 国内直连节点）的账号与任务数据关系官方文档未说明，按 APIMart 同款策略处理：
+// 只在能证明尚未建立连接时切换，不对已建立连接的失败重放计费请求。
+let preferredBaseUrl;
+function orderedBaseUrls() {
+    if (!preferredBaseUrl || preferredBaseUrl === GRSAI_API_BASE_URLS[0])
+        return GRSAI_API_BASE_URLS;
+    return [preferredBaseUrl, ...GRSAI_API_BASE_URLS.filter((baseUrl) => baseUrl !== preferredBaseUrl)];
+}
+export function buildGrsaiEndpoints(route) {
+    const normalizedRoute = route.startsWith('/') ? route : `/${route}`;
+    return orderedBaseUrls().map((baseUrl) => `${baseUrl}${normalizedRoute}`);
+}
+/** 把某个成功响应过的完整 endpoint URL 记为本进程后续请求的优先域名。 */
+export function markGrsaiEndpointReachable(endpoint) {
+    const matched = GRSAI_API_BASE_URLS.find((baseUrl) => endpoint.startsWith(baseUrl));
+    if (matched)
+        preferredBaseUrl = matched;
+}
+export function resetGrsaiEndpointPreference() {
+    preferredBaseUrl = undefined;
+}
+/**
+ * 应用启动后台探测：按默认顺序找出第一个当前网络下可达的域名并预热为优先域名，
+ * 让用户首次真实生成请求不必先撞一次必然失败的默认线路。不阻塞启动、探测失败静默忽略。
+ */
+export async function warmGrsaiEndpointPreference(transport) {
+    for (const baseUrl of GRSAI_API_BASE_URLS) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), WARMUP_TIMEOUT_MS);
+        try {
+            // 只探测连通性，不关心响应内容：未带 id 查询大概率返回 400，但只要网络层能连上就够了。
+            await transport.fetch(`${baseUrl}/v1/api/result`, { method: 'GET', signal: controller.signal });
+            preferredBaseUrl = baseUrl;
+            return;
+        }
+        catch {
+            continue;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/providers/fal.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderContinuePollingInput, ProviderExecutionInput, ProviderExecutionResult } from '../types/runtime.js';
+export declare function execute(input: ProviderExecutionInput): Promise<ProviderExecutionResult>;
+export declare function continuePolling(input: ProviderContinuePollingInput): Promise<ProviderExecutionResult>;

package/dist/providers/fal.js

@@ -0,0 +1,148 @@
+import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+import { pollUntilResult } from '../protocols/polling.js';
+import { collectDeepUrls, normalizeEndpoint, readJsonResponse } from './helpers.js';
+import { fetchProvider } from './provider-fetch.js';
+const FAL_SYNC_BASE_URL = 'https://fal.run';
+const FAL_QUEUE_BASE_URL = 'https://queue.fal.run';
+export async function execute(input) {
+    const syncMode = isJsonObject(input.body) && input.body.sync_mode === true;
+    const cleanInput = stripLocalSyncMode(input.body);
+    const payload = syncMode
+        ? await submit(input, normalizeEndpoint(FAL_SYNC_BASE_URL, input.route), cleanInput)
+        : await submit(input, normalizeEndpoint(FAL_QUEUE_BASE_URL, input.route), cleanInput);
+    if (!syncMode) {
+        // Fal 会返回服务端解析后的完整 status_url。它可能与本地 catalog route 不同
+        // （例如供应商给旧别名做了提交兼容，但查询只认 canonical endpoint），因此必须
+        // 优先保存完整 URL；只在响应没有 status_url 时才退回 request_id 并重建路径。
+        const returnedStatusUrl = readString(payload, 'status_url');
+        const taskId = returnedStatusUrl
+            ? requireFalQueueUrl(returnedStatusUrl, 'status_url')
+            : readString(payload, 'request_id');
+        if (!taskId) {
+            throw new AiRuntimeError('empty_result', 'Fal queue response has neither request_id nor status_url');
+        }
+        return { status: 'pending', url: '', taskId, metadata: payload };
+    }
+    assertFalSucceeded(payload);
+    const urls = extractUrls(payload);
+    if (urls.length === 0) {
+        throw new AiRuntimeError('empty_result', `Fal response has no media URL (request_id=${readString(payload, 'request_id') ?? input.requestId})`);
+    }
+    return { status: 'completed', url: urls.join('|||'), taskId: readString(payload, 'request_id'), metadata: payload };
+}
+export async function continuePolling(input) {
+    const statusUrl = /^https?:\/\//i.test(input.taskId)
+        ? requireFalQueueUrl(input.taskId, 'taskId')
+        : `${FAL_QUEUE_BASE_URL}/${input.route.replace(/^\/+/, '')}/requests/${input.taskId}/status`;
+    const finalPayload = await pollByStatusUrl(input, statusUrl);
+    const urls = extractUrls(finalPayload);
+    if (urls.length === 0) {
+        throw new AiRuntimeError('empty_result', `Fal response has no media URL (request_id=${input.taskId})`);
+    }
+    return { status: 'completed', url: urls.join('|||'), taskId: input.taskId, metadata: finalPayload };
+}
+async function submit(input, endpoint, cleanInput) {
+    const response = await fetchProvider('Fal', endpoint, {
+        method: 'POST',
+        headers: {
+            Authorization: `Key ${input.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(cleanInput),
+        signal: input.signal,
+    }, {
+        transport: input.runtime.transport,
+        retryPreconnectOnce: true,
+    });
+    return await readJsonResponse(response, 'Fal');
+}
+async function pollByStatusUrl(input, statusUrl) {
+    return await pollUntilResult(input, async () => {
+        const response = await input.runtime.transport.fetch(statusUrl, {
+            headers: { Authorization: `Key ${input.apiKey}` },
+            signal: input.signal,
+        });
+        const payload = await readJsonResponse(response, 'Fal');
+        const state = (readString(payload, 'status') ?? '').toUpperCase();
+        if (state === 'COMPLETED') {
+            assertFalSucceeded(payload);
+            const responseUrl = readString(payload, 'response_url');
+            const resultUrl = responseUrl
+                ? requireFalQueueUrl(responseUrl, 'response_url')
+                : statusUrl.replace(/\/status(?:\?.*)?$/, '');
+            const finalResponse = await fetchProvider('Fal', resultUrl, {
+                headers: { Authorization: `Key ${input.apiKey}` },
+                signal: input.signal,
+            }, {
+                transport: input.runtime.transport,
+                retryPreconnectOnce: true,
+            });
+            const result = await readJsonResponse(finalResponse, 'Fal');
+            assertFalSucceeded(result);
+            return enrichRequestId(result, input.taskId);
+        }
+        if (state === 'FAILED' || state === 'ERROR') {
+            throw new AiRuntimeError('provider_task_failed', 'Fal task failed');
+        }
+        return undefined;
+    });
+}
+function assertFalSucceeded(payload) {
+    if (!isJsonObject(payload))
+        return;
+    const message = readString(payload, 'error')
+        ?? readString(payload, 'detail')
+        ?? readString(payload, 'message');
+    const errorType = readString(payload, 'error_type');
+    if (message || errorType) {
+        throw new AiRuntimeError('provider_task_failed', message ?? errorType ?? 'Fal task failed');
+    }
+}
+function stripLocalSyncMode(value) {
+    if (!isJsonObject(value))
+        return value;
+    if (value.sync_mode !== true)
+        return value;
+    const next = { ...value };
+    delete next.sync_mode;
+    return next;
+}
+/** Fal Key 只能发送到官方队列源，避免持久化或导入的任务 URL 外带凭据。 */
+function requireFalQueueUrl(value, field) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_endpoint', `Fal ${field} is not a valid URL`);
+    }
+    if (parsed.origin !== FAL_QUEUE_BASE_URL || parsed.username || parsed.password) {
+        throw new AiRuntimeError('invalid_endpoint', `Fal ${field} must use ${FAL_QUEUE_BASE_URL}`);
+    }
+    return parsed.toString();
+}
+function extractUrls(payload) {
+    const urls = [];
+    collectDeepUrls(payload, urls);
+    return urls;
+}
+function enrichRequestId(value, requestId) {
+    return isJsonObject(value) ? { request_id: normalizeRequestId(requestId), ...value } : value;
+}
+function normalizeRequestId(taskId) {
+    if (!taskId.startsWith('http://') && !taskId.startsWith('https://'))
+        return taskId;
+    try {
+        const matched = new URL(taskId).pathname.match(/\/requests\/([^/]+)/);
+        return matched?.[1] ? decodeURIComponent(matched[1]) : taskId;
+    }
+    catch {
+        return taskId;
+    }
+}
+function readString(value, key) {
+    return isJsonObject(value) && typeof value[key] === 'string' ? value[key] : undefined;
+}
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/providers/grsai.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderContinuePollingInput, ProviderExecutionInput, ProviderExecutionResult } from '../types/runtime.js';
+export declare function execute(input: ProviderExecutionInput): Promise<ProviderExecutionResult>;
+export declare function continuePolling(input: ProviderContinuePollingInput): Promise<ProviderExecutionResult>;