@undefineds.co/xpod 0.3.58 → 0.3.61

package/dist/api/service/VercelChatService.js

@@ -1,556 +1,119 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VercelChatService = void 0;
-const openai_1 = require("@ai-sdk/openai");
-const ai_1 = require("ai");
 const global_logger_factory_1 = require("global-logger-factory");
-const undici_1 = require("undici");
 const AuthContext_1 = require("../auth/AuthContext");
-const types_1 = require("../../credential/schema/types");
-const provider_registry_1 = require("./provider-registry");
-const platform_ai_config_1 = require("./platform-ai-config");
-const chat_protocol_adapters_1 = require("./chat-protocol-adapters");
-const ai_gateway_transport_1 = require("./ai-gateway-transport");
-const provider_http_transport_1 = require("./provider-http-transport");
-const chat_routing_1 = require("./chat-routing");
-// Create a proxy-aware fetch function
-function createProxyFetch(proxyUrl) {
-    const agent = new undici_1.ProxyAgent(proxyUrl);
-    return (url, init) => fetch(url, { ...init, dispatcher: agent });
-}
+/**
+ * @deprecated Compatibility facade for legacy internal ChatService callers.
+ *
+ * Public `/v1/*` routes are owned by AiGatewayHandler. This class only keeps
+ * older ChatKit/internal call sites working while routing every inference and
+ * model-list request through the unified AI Connection gateway runtime.
+ */
 class VercelChatService {
-    constructor(store) {
-        this.store = store;
+    constructor(_store, options = {}) {
+        this._store = _store;
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
-        this.providerHttpTransport = new provider_http_transport_1.ProviderHttpTransport();
-        this.logger.info('Initializing VercelChatService with Pod-based config support');
-        this.aiGatewayTransport = new ai_gateway_transport_1.AiGatewayTransport({
-            getBaseUrl: () => this.getAiGatewayBaseUrl(),
-            getApiKey: () => this.getAiGatewayApiKey(),
-            getQueryTimeoutMs: () => this.getAiGatewayQueryTimeoutMs(),
-            getGenerationTimeoutMs: () => this.getAiGatewayGenerationTimeoutMs(),
-        });
+        this.logger.info('Initializing legacy VercelChatService facade with AI Connection gateway runtime');
+        this.aiGatewayService = options.aiGatewayService;
     }
     /**
-     * Set optional usage tracking dependencies (injected after construction)
+     * Set optional usage tracking dependencies (injected after construction).
      */
     setUsageTracking(usageRepo, quotaService) {
         this.usageRepo = usageRepo;
         this.quotaService = quotaService;
     }
-    /**
-     * Create a StoreContext from AuthContext for Pod operations
-     */
-    createStoreContext(auth) {
-        return {
-            userId: (0, AuthContext_1.getWebId)(auth) ?? (0, AuthContext_1.getAccountId)(auth) ?? 'anonymous',
-            auth,
-        };
-    }
-    getAiGatewayBaseUrl() {
-        return (0, platform_ai_config_1.getAiGatewayBaseUrl)() ?? null;
-    }
-    getAiGatewayQueryTimeoutMs() {
-        return (0, platform_ai_config_1.getPlatformQueryTimeoutMs)();
-    }
-    getAiGatewayGenerationTimeoutMs() {
-        return (0, platform_ai_config_1.getPlatformGenerationTimeoutMs)();
-    }
-    getAiGatewayApiKey() {
-        return (0, platform_ai_config_1.getAiGatewayApiKey)() ?? null;
-    }
-    async shouldUseAiGateway(model) {
-        return this.aiGatewayTransport.shouldHandleModel(model);
-    }
-    toModelId(model) {
-        return typeof model?.id === 'string' ? model.id : JSON.stringify(model);
-    }
-    pushModelsWithDedup(models, seenModelIds, items) {
-        for (const model of items) {
-            const modelId = this.toModelId(model);
-            if (seenModelIds.has(modelId)) {
-                continue;
-            }
-            seenModelIds.add(modelId);
-            models.push(model);
-        }
-    }
-    async forwardAiGatewayJson(path, body, _auth) {
-        return this.aiGatewayTransport.sendJson(path, body);
-    }
-    async forwardAiGatewayStream(path, body, _auth) {
-        return this.aiGatewayTransport.sendStream(path, body);
-    }
-    getProviderChatCompletionsUrl(baseURL) {
-        const cleanBaseUrl = baseURL.endsWith('/') ? baseURL.slice(0, -1) : baseURL;
-        return cleanBaseUrl.endsWith('/chat/completions')
-            ? cleanBaseUrl
-            : `${cleanBaseUrl}/chat/completions`;
-    }
-    extractTotalTokens(usage) {
-        if (!usage || typeof usage !== 'object') {
-            return 0;
-        }
-        if (typeof usage.total_tokens === 'number') {
-            return usage.total_tokens;
-        }
-        if (typeof usage.totalTokens === 'number') {
-            return usage.totalTokens;
-        }
-        if (typeof usage.input_tokens === 'number' || typeof usage.output_tokens === 'number') {
-            return (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
-        }
-        if (typeof usage.prompt_tokens === 'number' || typeof usage.completion_tokens === 'number') {
-            return (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0);
-        }
-        return 0;
-    }
-    recordForwardedUsage(accountId, podId, payload) {
-        const totalTokens = this.extractTotalTokens(payload?.usage);
-        if (accountId && totalTokens > 0) {
-            this.recordTokenUsage(accountId, podId, totalTokens);
-        }
-    }
-    async getProviderConfig(context) {
-        let config;
-        try {
-            config = await this.store.getAiConfig(context);
-            this.logger.info(`Pod config: ${JSON.stringify(config)}`);
-        }
-        catch (error) {
-            this.logger.warn(`Failed to get Pod config, falling back to defaults: ${error}`);
-            config = undefined;
-        }
-        // Priority: Pod config > Platform Provider
-        if (config?.apiKey) {
-            const baseURL = config.baseUrl || (0, provider_registry_1.getDefaultBaseUrl)();
-            const proxy = config.proxyUrl;
-            this.logger.info(`Provider config: baseURL=${baseURL}, proxy=${proxy || 'none'} (source=pod)`);
-            return { baseURL, apiKey: config.apiKey, proxy, credentialId: config.credentialId };
-        }
-        // 平台 Provider
-        const platformBase = (0, platform_ai_config_1.getPlatformApiBaseUrl)();
-        if (platformBase) {
-            this.logger.info(`Provider config: baseURL=${platformBase}, proxy=none (source=platform)`);
-            return { baseURL: platformBase, apiKey: (0, platform_ai_config_1.getPlatformApiKey)(), proxy: undefined, credentialId: undefined };
-        }
-        this.logger.warn('No AI provider config found in Pod or DEFAULT_API_BASE');
-        return null;
-    }
-    async getProvider(context) {
-        const providerConfig = await this.getProviderConfig(context);
-        if (!providerConfig) {
-            const err = new Error('No AI provider configured. Please configure Pod AI provider or set DEFAULT_API_BASE.');
-            err.code = 'model_not_configured';
-            throw err;
-        }
-        const { baseURL, apiKey, proxy } = providerConfig;
-        this.logger.debug(`Using AI Provider: ${baseURL} (key length: ${apiKey?.length || 0}, proxy: ${proxy || 'none'})`);
-        const options = { baseURL, apiKey };
-        if (proxy) {
-            options.fetch = createProxyFetch(proxy);
-        }
-        return (0, openai_1.createOpenAI)(options);
-    }
     async complete(request, auth) {
-        const { model } = request;
-        const context = this.createStoreContext(auth);
         const accountId = (0, AuthContext_1.getAccountId)(auth);
         if (accountId) {
             await this.checkTokenQuota(accountId);
         }
-        if (await (0, chat_routing_1.resolveChatExecutionRoute)({ model, shouldUseAiGateway: this.shouldUseAiGateway.bind(this) }) === 'ai-gateway') {
-            this.logger.info(`Forwarding chat completion for model ${model} to ai-gateway`);
-            const result = await this.forwardAiGatewayJson('/v1/chat/completions', request, auth);
-            this.recordForwardedUsage(accountId, String(context.userId), result);
-            return result;
-        }
-        const config = await this.getProviderConfig(context);
-        if (!config) {
-            const err = new Error('No AI provider configured. Please configure Pod AI provider or set DEFAULT_API_BASE.');
-            err.code = 'model_not_configured';
-            throw err;
-        }
-        try {
-            const result = await this.providerHttpTransport.postJson({
-                url: this.getProviderChatCompletionsUrl(config.baseURL),
-                apiKey: config.apiKey,
-                proxy: config.proxy,
-                body: request,
-            });
-            // Record successful API call
-            if (config?.credentialId) {
-                this.store.recordCredentialSuccess(context, config.credentialId).catch((err) => {
-                    this.logger.debug(`Failed to record credential success: ${err}`);
-                });
-            }
-            // Record token usage
-            const totalTokens = this.extractTotalTokens(result.usage);
-            if (accountId && totalTokens > 0) {
-                this.recordTokenUsage(accountId, String(context.userId), totalTokens);
-            }
-            return result;
-        }
-        catch (error) {
-            this.logger.error(`AI completion failed: ${error}`);
-            // Handle error and update credential status
-            if (config?.credentialId) {
-                await this.handleApiError(error, context, config.credentialId);
-            }
-            throw error;
-        }
+        const result = await this.completeViaGateway('chatCompletions', request, auth);
+        this.recordForwardedUsage(accountId, this.podUsageScope(auth), result);
+        return result;
     }
     async stream(request, auth) {
-        const { model } = request;
-        const context = this.createStoreContext(auth);
-        if (await (0, chat_routing_1.resolveChatExecutionRoute)({ model, shouldUseAiGateway: this.shouldUseAiGateway.bind(this) }) === 'ai-gateway') {
-            this.logger.info(`Forwarding chat stream for model ${model} to ai-gateway`);
-            return this.forwardAiGatewayStream('/v1/chat/completions', request, auth);
-        }
-        const config = await this.getProviderConfig(context);
-        if (!config) {
-            const err = new Error('No AI provider configured. Please configure Pod AI provider or set DEFAULT_API_BASE.');
-            err.code = 'model_not_configured';
-            throw err;
-        }
-        const response = await this.providerHttpTransport.postStream({
-            url: this.getProviderChatCompletionsUrl(config.baseURL),
-            apiKey: config.apiKey,
-            proxy: config.proxy,
-            body: request,
-            headers: {
-                Accept: 'text/event-stream',
-            },
-        });
+        const gateway = this.requireAiGatewayService();
         return {
-            toTextStreamResponse: () => new Response(response.body, {
-                status: response.status,
-                statusText: response.statusText,
-                headers: new Headers(response.headers),
+            toTextStreamResponse: () => gatewayExecutionToTextStreamResponse(gateway, {
+                auth,
+                protocol: 'chatCompletions',
+                body: request,
             }),
         };
     }
     async responses(body, auth) {
-        const context = this.createStoreContext(auth);
-        const displayName = (0, AuthContext_1.getDisplayName)(auth) || context.userId;
-        const accountId = (0, AuthContext_1.getAccountId)(auth);
-        if (await (0, chat_routing_1.resolveChatExecutionRoute)({ model: body?.model, shouldUseAiGateway: this.shouldUseAiGateway.bind(this) }) === 'ai-gateway') {
-            this.logger.info(`Forwarding responses request for model ${body?.model} to ai-gateway for ${displayName} (acc: ${accountId})`);
-            const sanitizedBody = (0, chat_protocol_adapters_1.sanitizeAiGatewayResponsesBody)(body);
-            const result = await this.forwardAiGatewayJson('/v1/responses', sanitizedBody, auth);
-            this.recordForwardedUsage(accountId, String(context.userId), result);
-            return result;
-        }
-        const providerConfig = await this.getProviderConfig(context);
-        if (!providerConfig) {
-            const err = new Error('No AI provider configured. Please configure Pod AI provider or set DEFAULT_API_BASE.');
-            err.code = 'model_not_configured';
-            throw err;
-        }
-        const { baseURL } = providerConfig;
-        // Only OpenAI natively supports /v1/responses; all others go through Chat Completions
-        if ((0, chat_routing_1.resolveResponsesProviderRoute)(baseURL) === 'chat-fallback') {
-            this.logger.info(`Provider ${baseURL} does not support Responses API, converting to Chat Completions for ${displayName} (acc: ${accountId})`);
-            return this.responsesViaCompletions(body, context, providerConfig);
-        }
-        const { apiKey, proxy, credentialId } = providerConfig;
-        // Remove trailing slash if present
-        const cleanBaseUrl = baseURL.endsWith('/') ? baseURL.slice(0, -1) : baseURL;
-        const url = `${cleanBaseUrl}/responses`;
-        this.logger.info(`Proxying responses request to ${url} for ${displayName} (acc: ${accountId}), proxy: ${proxy || 'none'}`);
-        try {
-            const result = await this.providerHttpTransport.postJson({
-                url,
-                apiKey,
-                proxy,
-                body,
-            });
-            if (credentialId) {
-                this.store.recordCredentialSuccess(context, credentialId).catch(() => { });
-            }
-            return result;
-        }
-        catch (error) {
-            const status = error?.status;
-            const headers = error?.headers;
-            const bodyText = error?.body;
-            if (typeof status === 'number') {
-                this.logger.error(`Responses API failed: ${status} ${bodyText ?? ''}`);
-                if (credentialId) {
-                    await this.handleApiError({ status, headers }, context, credentialId);
-                }
-            }
-            else if (credentialId) {
-                await this.handleApiError(error, context, credentialId);
-            }
-            throw error;
-        }
+        const result = await this.completeViaGateway('responses', body, auth);
+        this.recordForwardedUsage((0, AuthContext_1.getAccountId)(auth), this.podUsageScope(auth), result);
+        return result;
     }
     async messages(body, auth) {
-        const context = this.createStoreContext(auth);
-        const displayName = (0, AuthContext_1.getDisplayName)(auth) || context.userId;
-        const accountId = (0, AuthContext_1.getAccountId)(auth);
-        if (await (0, chat_routing_1.resolveChatExecutionRoute)({ model: body?.model, shouldUseAiGateway: this.shouldUseAiGateway.bind(this) }) === 'ai-gateway') {
-            this.logger.info(`Forwarding messages request for model ${body?.model} to ai-gateway for ${displayName} (acc: ${accountId})`);
-            const completionBody = (0, chat_protocol_adapters_1.buildChatCompletionsBodyFromMessages)(body);
-            const completion = await this.forwardAiGatewayJson('/v1/chat/completions', completionBody, auth);
-            const result = (0, chat_protocol_adapters_1.mapChatCompletionToMessagesResponse)(body, completion);
-            this.recordForwardedUsage(accountId, String(context.userId), result);
-            return result;
-        }
-        const providerConfig = await this.getProviderConfig(context);
-        if (!providerConfig) {
-            const err = new Error('No AI provider configured. Please configure Pod AI provider or set DEFAULT_API_BASE.');
-            err.code = 'model_not_configured';
-            throw err;
-        }
-        const { baseURL } = providerConfig;
-        // Only Anthropic natively supports /v1/messages; all others go through Chat Completions
-        if ((0, chat_routing_1.resolveMessagesProviderRoute)(baseURL) === 'chat-fallback') {
-            this.logger.info(`Provider ${baseURL} does not support Messages API, converting to Chat Completions for ${displayName} (acc: ${accountId})`);
-            return this.messagesViaCompletions(body, context, providerConfig);
-        }
-        const { apiKey, proxy, credentialId } = providerConfig;
-        // Remove trailing slash if present
-        const cleanBaseUrl = baseURL.endsWith('/') ? baseURL.slice(0, -1) : baseURL;
-        const url = `${cleanBaseUrl}/messages`;
-        this.logger.info(`Proxying messages request to ${url} for ${displayName} (acc: ${accountId}), proxy: ${proxy || 'none'}`);
-        try {
-            const result = await this.providerHttpTransport.postJson({
-                url,
-                apiKey,
-                proxy,
-                body,
-                headers: {
-                    'x-api-key': apiKey,
-                    'anthropic-version': '2023-06-01',
-                },
-            });
-            if (credentialId) {
-                this.store.recordCredentialSuccess(context, credentialId).catch(() => { });
-            }
-            return result;
-        }
-        catch (error) {
-            const status = error?.status;
-            const headers = error?.headers;
-            const bodyText = error?.body;
-            if (typeof status === 'number') {
-                this.logger.error(`Messages API failed: ${status} ${bodyText ?? ''}`);
-                if (credentialId) {
-                    await this.handleApiError({ status, headers }, context, credentialId);
-                }
-            }
-            else if (credentialId) {
-                await this.handleApiError(error, context, credentialId);
-            }
-            throw error;
-        }
+        const result = await this.completeViaGateway('anthropic', body, auth);
+        this.recordForwardedUsage((0, AuthContext_1.getAccountId)(auth), this.podUsageScope(auth), result);
+        return result;
     }
-    async responsesViaCompletions(body, context, providerConfig) {
-        const prompt = (0, chat_protocol_adapters_1.extractPromptFromResponsesBody)(body);
-        const model = body?.model || (0, platform_ai_config_1.getPlatformDefaultModel)();
-        const provider = await this.getProvider(context);
-        const result = await (0, ai_1.generateText)({
-            model: provider.chat(model),
-            messages: [{ role: 'user', content: prompt }],
-            ...(body?.temperature != null ? { temperature: body.temperature } : {}),
-            ...(body?.max_output_tokens != null ? { maxTokens: body.max_output_tokens } : {}),
-        });
-        if (providerConfig.credentialId) {
-            this.store.recordCredentialSuccess(context, providerConfig.credentialId).catch(() => { });
+    async listModels(auth) {
+        if (!auth) {
+            return [];
         }
-        const outputText = result.text;
-        const now = Math.floor(Date.now() / 1000);
-        return {
-            id: `resp_${Date.now()}`,
-            object: 'response',
-            created: now,
-            status: 'completed',
-            model,
-            output: [{
-                    type: 'message',
-                    role: 'assistant',
-                    content: [{ type: 'output_text', text: outputText }],
-                }],
-            usage: {
-                input_tokens: result.usage?.promptTokens ?? prompt.length,
-                output_tokens: result.usage?.completionTokens ?? outputText.length,
-                total_tokens: result.usage?.totalTokens ?? (prompt.length + outputText.length),
-            },
-        };
+        return await this.requireAiGatewayService().listModels(auth);
     }
-    async messagesViaCompletions(body, context, providerConfig) {
-        const prompt = (0, chat_protocol_adapters_1.extractPromptFromMessagesBody)(body);
-        const model = body?.model || (0, platform_ai_config_1.getPlatformDefaultModel)();
-        const coreMessages = [];
-        if (body?.system) {
-            const systemText = typeof body.system === 'string'
-                ? body.system
-                : Array.isArray(body.system)
-                    ? body.system.map((b) => b?.text ?? '').join('\n')
-                    : '';
-            if (systemText) {
-                coreMessages.push({ role: 'system', content: systemText });
-            }
-        }
-        if (Array.isArray(body?.messages)) {
-            for (const msg of body.messages) {
-                if (msg?.role && msg?.content != null) {
-                    const content = typeof msg.content === 'string'
-                        ? msg.content
-                        : Array.isArray(msg.content)
-                            ? msg.content.filter((p) => p?.type === 'text').map((p) => p.text).join('\n')
-                            : String(msg.content);
-                    coreMessages.push({ role: msg.role, content });
-                }
-            }
-        }
-        if (coreMessages.length === 0) {
-            coreMessages.push({ role: 'user', content: prompt });
-        }
-        const provider = await this.getProvider(context);
-        const result = await (0, ai_1.generateText)({
-            model: provider.chat(model),
-            messages: coreMessages,
-            ...(body?.temperature != null ? { temperature: body.temperature } : {}),
-            ...(body?.max_tokens != null ? { maxTokens: body.max_tokens } : {}),
+    async completeViaGateway(protocol, body, auth) {
+        return await this.requireAiGatewayService().complete({
+            auth,
+            protocol,
+            body,
         });
-        if (providerConfig.credentialId) {
-            this.store.recordCredentialSuccess(context, providerConfig.credentialId).catch(() => { });
+    }
+    requireAiGatewayService() {
+        if (!this.aiGatewayService) {
+            throw new Error('AiGatewayService is required for legacy ChatKit AI inference');
         }
-        const text = result.text;
-        return {
-            id: `msg_${Date.now()}`,
-            type: 'message',
-            role: 'assistant',
-            model,
-            content: [{ type: 'text', text }],
-            stop_reason: 'end_turn',
-            stop_sequence: null,
-            usage: {
-                input_tokens: result.usage?.promptTokens ?? prompt.length,
-                output_tokens: result.usage?.completionTokens ?? text.length,
-            },
-        };
+        return this.aiGatewayService;
     }
-    async listModels(_auth) {
-        const models = [];
-        const seenModelIds = new Set();
-        if (_auth) {
-            try {
-                const context = this.createStoreContext(_auth);
-                const userModels = await this.store.listAvailableModels(context);
-                this.pushModelsWithDedup(models, seenModelIds, userModels);
-            }
-            catch (error) {
-                this.logger.warn(`Failed to load user Pod models: ${error}`);
-            }
+    podUsageScope(auth) {
+        return (0, AuthContext_1.getWebId)(auth) ?? (0, AuthContext_1.getAccountId)(auth) ?? 'anonymous';
+    }
+    extractTotalTokens(usage) {
+        if (!usage || typeof usage !== 'object') {
+            return 0;
         }
-        const aiGatewayModels = await this.aiGatewayTransport.listModels();
-        if (aiGatewayModels) {
-            this.pushModelsWithDedup(models, seenModelIds, aiGatewayModels);
+        const record = usage;
+        if (typeof record.total_tokens === 'number') {
+            return record.total_tokens;
         }
-        // 平台 Provider 模型（从 DEFAULT_API_BASE 获取）
-        const platformBase = (0, platform_ai_config_1.getPlatformApiBaseUrl)();
-        const platformKey = (0, platform_ai_config_1.getPlatformApiKey)();
-        const aiGatewayBase = this.getAiGatewayBaseUrl();
-        const normalizedAiGatewayModelsUrl = aiGatewayBase
-            ? this.aiGatewayTransport.buildUrl('/v1/models')
-            : undefined;
-        const normalizedPlatformModelsUrl = platformBase
-            ? `${platformBase.replace(/\/$/, '')}/models`
-            : undefined;
-        if (platformBase && normalizedPlatformModelsUrl !== normalizedAiGatewayModelsUrl) {
-            try {
-                const url = normalizedPlatformModelsUrl;
-                const headers = { 'Content-Type': 'application/json' };
-                if (platformKey) {
-                    headers['Authorization'] = `Bearer ${platformKey}`;
-                }
-                const resp = await fetch(url, { headers });
-                if (resp.ok) {
-                    const data = await resp.json();
-                    if (Array.isArray(data.data)) {
-                        this.pushModelsWithDedup(models, seenModelIds, data.data);
-                    }
-                }
-                else {
-                    this.logger.warn(`Failed to fetch platform models: ${resp.status}`);
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Failed to fetch platform models: ${error}`);
-            }
+        if (typeof record.totalTokens === 'number') {
+            return record.totalTokens;
         }
-        return models;
-    }
-    /**
-     * Handle API errors and update credential status accordingly
-     */
-    async handleApiError(error, context, credentialId) {
-        const errorInfo = this.parseApiError(error);
-        if (errorInfo.statusCode === 429) {
-            // Rate limit error - mark credential as rate limited
-            const resetAt = errorInfo.retryAfter
-                ? new Date(Date.now() + errorInfo.retryAfter * 1000)
-                : new Date(Date.now() + 60000); // Default 1 minute cooldown
-            this.logger.warn(`Rate limit hit for credential ${credentialId}, reset at: ${resetAt.toISOString()}`);
-            await this.store.updateCredentialStatus(context, credentialId, types_1.CredentialStatus.RATE_LIMITED, { rateLimitResetAt: resetAt });
+        if (typeof record.input_tokens === 'number' || typeof record.output_tokens === 'number') {
+            return (Number(record.input_tokens) || 0) + (Number(record.output_tokens) || 0);
         }
-        else if (errorInfo.statusCode === 401 || errorInfo.statusCode === 403) {
-            // Auth error - mark credential as inactive
-            this.logger.warn(`Auth error for credential ${credentialId}, marking as inactive`);
-            await this.store.updateCredentialStatus(context, credentialId, types_1.CredentialStatus.INACTIVE, { incrementFailCount: true });
-        }
-        else if (errorInfo.statusCode >= 500) {
-            // Server error - increment fail count but keep active
-            this.logger.warn(`Server error ${errorInfo.statusCode} for credential ${credentialId}`);
-            await this.store.updateCredentialStatus(context, credentialId, types_1.CredentialStatus.ACTIVE, { incrementFailCount: true });
+        if (typeof record.prompt_tokens === 'number' || typeof record.completion_tokens === 'number') {
+            return (Number(record.prompt_tokens) || 0) + (Number(record.completion_tokens) || 0);
         }
+        return 0;
     }
-    /**
-     * Parse error to extract status code and retry-after header
-     */
-    parseApiError(error) {
-        // Handle different error formats from AI SDK
-        if (error && typeof error === 'object') {
-            const err = error;
-            // Direct status code
-            if (typeof err.status === 'number') {
-                return {
-                    statusCode: err.status,
-                    retryAfter: err.retryAfter || err.headers?.['retry-after'],
-                };
-            }
-            // Nested response object
-            if (err.response && typeof err.response.status === 'number') {
-                return {
-                    statusCode: err.response.status,
-                    retryAfter: err.response.headers?.get?.('retry-after'),
-                };
-            }
-            // Error message parsing (fallback)
-            if (err.message) {
-                const match = err.message.match(/(\d{3})/);
-                if (match) {
-                    return { statusCode: parseInt(match[1], 10) };
-                }
-            }
+    recordForwardedUsage(accountId, podId, payload) {
+        const usage = payload && typeof payload === 'object'
+            ? payload.usage
+            : undefined;
+        const totalTokens = this.extractTotalTokens(usage);
+        if (accountId && totalTokens > 0) {
+            this.recordTokenUsage(accountId, podId, totalTokens);
         }
-        return { statusCode: 0 };
     }
     /**
-     * Check if account has remaining token quota
+     * Check if account has remaining token quota.
      */
     async checkTokenQuota(accountId) {
         if (!this.quotaService || !this.usageRepo) {
-            return; // No quota enforcement if not configured
+            return;
         }
         try {
             const quota = await this.quotaService.getAccountQuota(accountId);
             if (!quota.tokenLimitMonthly) {
-                return; // No limit set
+                return;
             }
             const usage = await this.usageRepo.getAccountUsage(accountId);
             const tokensUsed = usage?.tokensUsed ?? 0;
@@ -564,12 +127,11 @@ class VercelChatService {
             if (error.code === 'quota_exceeded') {
                 throw error;
             }
-            // Log but don't block on quota check errors
             this.logger.warn(`Token quota check failed: ${error}`);
         }
     }
     /**
-     * Record token usage (fire-and-forget)
+     * Record token usage (fire-and-forget).
      */
     recordTokenUsage(accountId, podId, tokens) {
         if (!this.usageRepo) {
@@ -581,4 +143,90 @@ class VercelChatService {
     }
 }
 exports.VercelChatService = VercelChatService;
+function gatewayExecutionToTextStreamResponse(gateway, input) {
+    const encoder = new TextEncoder();
+    const abortController = new AbortController();
+    let iterator;
+    let cancelRequested = false;
+    let iteratorReturned = false;
+    const returnIterator = async () => {
+        if (!iterator) {
+            return;
+        }
+        if (iteratorReturned) {
+            return;
+        }
+        iteratorReturned = true;
+        await iterator?.return?.();
+    };
+    const pump = async (controller) => {
+        try {
+            const execution = await gateway.execute({
+                ...input,
+                signal: abortController.signal,
+            });
+            const serializer = execution.frontend.createEventSerializer();
+            iterator = execution.events[Symbol.asyncIterator]();
+            if (cancelRequested) {
+                await returnIterator();
+                return;
+            }
+            while (true) {
+                if (cancelRequested) {
+                    break;
+                }
+                const result = await iterator.next();
+                if (result.done) {
+                    break;
+                }
+                if (cancelRequested) {
+                    break;
+                }
+                const event = result.value;
+                const serialized = serializer.serializeEvent(event);
+                for (const item of Array.isArray(serialized) ? serialized : [serialized]) {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(item)}\n\n`));
+                }
+            }
+            if (cancelRequested) {
+                return;
+            }
+            controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+            controller.close();
+        }
+        catch (error) {
+            if (abortController.signal.aborted) {
+                try {
+                    controller.close();
+                }
+                catch {
+                    // Stream may already be closed by cancel().
+                }
+            }
+            else {
+                controller.error(error);
+            }
+        }
+        finally {
+            await returnIterator();
+        }
+    };
+    const stream = new ReadableStream({
+        start(controller) {
+            void pump(controller);
+        },
+        async cancel() {
+            cancelRequested = true;
+            abortController.abort();
+            await returnIterator();
+        },
+    });
+    return new Response(stream, {
+        status: 200,
+        headers: {
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache, no-transform',
+        },
+    });
+}
 //# sourceMappingURL=VercelChatService.js.map