bazaar.it 0.1.0 → 0.2.1

package/dist/lib/api.js

@@ -0,0 +1,719 @@
+import { parseSSEEvent } from './sse.js';
+/**
+ * Error codes for better CLI error handling
+ * These map to semantic exit codes for agent consumption
+ */
+export const ErrorCodes = {
+    // Auth errors (exit code 13)
+    AUTH_MISSING: 'AUTH_MISSING',
+    AUTH_INVALID: 'AUTH_INVALID',
+    AUTH_EXPIRED: 'AUTH_EXPIRED',
+    FORBIDDEN: 'FORBIDDEN',
+    // Input/validation errors (exit code 64-66)
+    NOT_FOUND: 'NOT_FOUND',
+    VALIDATION: 'VALIDATION',
+    // Transient errors (exit code 10)
+    RATE_LIMIT: 'RATE_LIMIT',
+    // Resource errors (exit code 11)
+    BALANCE: 'BALANCE',
+    CAPACITY: 'CAPACITY',
+    // Semantic errors (exit code 12)
+    CONTENT_FILTER: 'CONTENT_FILTER',
+    // Server/network errors (exit code 10 - retryable)
+    SERVER: 'SERVER',
+    NETWORK: 'NETWORK',
+    TIMEOUT: 'TIMEOUT',
+    // Fatal (exit code 1)
+    UNKNOWN: 'UNKNOWN',
+};
+/**
+ * Map error codes to categories
+ */
+export function getErrorCategory(code) {
+    switch (code) {
+        case ErrorCodes.AUTH_MISSING:
+        case ErrorCodes.AUTH_INVALID:
+        case ErrorCodes.AUTH_EXPIRED:
+        case ErrorCodes.FORBIDDEN:
+            return 'auth';
+        case ErrorCodes.NOT_FOUND:
+        case ErrorCodes.VALIDATION:
+            return 'validation';
+        case ErrorCodes.RATE_LIMIT:
+        case ErrorCodes.SERVER:
+        case ErrorCodes.NETWORK:
+        case ErrorCodes.TIMEOUT:
+            return 'transient';
+        case ErrorCodes.BALANCE:
+        case ErrorCodes.CAPACITY:
+            return 'resource';
+        case ErrorCodes.CONTENT_FILTER:
+            return 'semantic';
+        default:
+            return 'fatal';
+    }
+}
+/**
+ * Map error codes to exit codes for agent consumption
+ * Based on research: 0=success, 10=transient, 11=capacity, 12=semantic, 13=auth, 64-66=validation, 1=fatal
+ */
+export function getExitCode(code) {
+    switch (code) {
+        case ErrorCodes.RATE_LIMIT:
+        case ErrorCodes.SERVER:
+        case ErrorCodes.NETWORK:
+        case ErrorCodes.TIMEOUT:
+            return 10; // Transient - retry with backoff
+        case ErrorCodes.BALANCE:
+        case ErrorCodes.CAPACITY:
+            return 11; // Resource exhaustion
+        case ErrorCodes.CONTENT_FILTER:
+            return 12; // Semantic - rephrase prompt
+        case ErrorCodes.AUTH_MISSING:
+        case ErrorCodes.AUTH_INVALID:
+        case ErrorCodes.AUTH_EXPIRED:
+        case ErrorCodes.FORBIDDEN:
+            return 13; // Auth - escalate to human
+        case ErrorCodes.NOT_FOUND:
+            return 64; // Input error
+        case ErrorCodes.VALIDATION:
+            return 65; // Validation error
+        default:
+            return 1; // Fatal
+    }
+}
+/**
+ * Check if error is retryable
+ */
+export function isRetryable(code) {
+    const category = getErrorCategory(code);
+    return category === 'transient' || category === 'resource';
+}
+/**
+ * Check if error is transient (temporary)
+ */
+export function isTransient(code) {
+    return getErrorCategory(code) === 'transient';
+}
+/**
+ * Custom API error with agent-friendly metadata
+ * Includes: code, category, retryable, transient, suggestion, retryAfter
+ */
+export class ApiError extends Error {
+    code;
+    category;
+    retryable;
+    transient;
+    exitCode;
+    statusCode;
+    details;
+    suggestion;
+    retryAfter; // seconds to wait before retry
+    constructor(message, code, options) {
+        super(message);
+        this.name = 'ApiError';
+        this.code = code;
+        this.category = getErrorCategory(code);
+        this.retryable = isRetryable(code);
+        this.transient = isTransient(code);
+        this.exitCode = getExitCode(code);
+        this.statusCode = options?.statusCode;
+        this.details = options?.details;
+        this.suggestion = options?.suggestion;
+        this.retryAfter = options?.retryAfter;
+    }
+    /**
+     * Convert to JSON for agent consumption
+     */
+    toJSON() {
+        return {
+            type: 'error',
+            code: this.code,
+            errorType: this.code, // Alias for compatibility
+            message: this.message,
+            category: this.category,
+            retryable: this.retryable,
+            transient: this.transient,
+            exitCode: this.exitCode,
+            ...(this.retryAfter !== undefined && { retryAfter: this.retryAfter }),
+            ...(this.suggestion && { suggestion: this.suggestion }),
+            ...(this.details && { details: this.details }),
+        };
+    }
+}
+/**
+ * Parse API error response into agent-friendly error
+ */
+function parseApiError(status, statusText, body, headers) {
+    let message = `API error: ${status} ${statusText}`;
+    let details;
+    let code = ErrorCodes.UNKNOWN;
+    let suggestion;
+    let retryAfter;
+    // Parse Retry-After header if present
+    if (headers) {
+        const retryHeader = headers.get('Retry-After');
+        if (retryHeader) {
+            const parsed = parseInt(retryHeader, 10);
+            if (!isNaN(parsed)) {
+                retryAfter = parsed;
+            }
+        }
+    }
+    // Try to parse JSON error body
+    try {
+        const json = JSON.parse(body);
+        if (json.error?.message) {
+            message = json.error.message;
+        }
+        else if (json.message) {
+            message = json.message;
+        }
+        if (json.error?.details || json.details) {
+            details = json.error?.details || json.details;
+        }
+        // Check for retry_after in response body
+        if (json.retry_after || json.retryAfter) {
+            retryAfter = json.retry_after || json.retryAfter;
+        }
+        // Check for specific error codes from server
+        if (json.error?.code || json.code) {
+            const serverCode = json.error?.code || json.code;
+            if (serverCode === 'INSUFFICIENT_BALANCE') {
+                code = ErrorCodes.BALANCE;
+                suggestion = 'Top up your balance at https://bazaar.it/settings/billing';
+            }
+            else if (serverCode === 'CONTENT_POLICY_VIOLATION' || serverCode === 'SAFETY_FILTER') {
+                code = ErrorCodes.CONTENT_FILTER;
+                suggestion = 'Rephrase your prompt to avoid restricted content';
+            }
+            else if (serverCode === 'CAPACITY_EXCEEDED' || serverCode === 'GPU_UNAVAILABLE') {
+                code = ErrorCodes.CAPACITY;
+                suggestion = 'GPU resources busy. Try again in a few minutes';
+                retryAfter = retryAfter || 60;
+            }
+        }
+    }
+    catch {
+        if (body && body.length < 200) {
+            details = body;
+        }
+    }
+    // Map HTTP status to error code and suggestions
+    switch (status) {
+        case 401:
+            code = ErrorCodes.AUTH_INVALID;
+            message = 'Authentication failed';
+            suggestion = 'Check your API key or run: baz auth login <api-key>';
+            break;
+        case 403:
+            code = ErrorCodes.FORBIDDEN;
+            message = 'Access denied';
+            suggestion = 'Your API key may not have permission for this operation';
+            break;
+        case 404:
+            code = ErrorCodes.NOT_FOUND;
+            message = 'Resource not found';
+            suggestion = 'The project or resource may have been deleted';
+            break;
+        case 400:
+            code = ErrorCodes.VALIDATION;
+            // Keep the parsed message for validation errors
+            break;
+        case 402:
+            code = ErrorCodes.BALANCE;
+            message = 'Insufficient balance';
+            suggestion = 'Top up your balance at https://bazaar.it/settings/billing';
+            break;
+        case 429:
+            code = ErrorCodes.RATE_LIMIT;
+            message = 'Rate limit exceeded';
+            suggestion = retryAfter
+                ? `Wait ${retryAfter} seconds and try again`
+                : 'Wait a moment and try again';
+            retryAfter = retryAfter || 30; // Default to 30s for rate limits
+            break;
+        case 408:
+            code = ErrorCodes.TIMEOUT;
+            message = 'Request timed out';
+            suggestion = 'Try again or reduce request complexity';
+            retryAfter = 5;
+            break;
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            code = ErrorCodes.SERVER;
+            message = 'Server error';
+            suggestion = 'Try again in a few minutes';
+            retryAfter = retryAfter || 60;
+            break;
+    }
+    return new ApiError(message, code, { statusCode: status, details, suggestion, retryAfter });
+}
+/**
+ * Make a tRPC-style API request
+ *
+ * Since we're calling the server directly without the tRPC client,
+ * we use the HTTP batch format.
+ */
+export async function apiRequest(config, procedure, input) {
+    if (!config.apiKey) {
+        throw new ApiError('No API key configured', ErrorCodes.AUTH_MISSING, { suggestion: 'Run: baz auth login <api-key>' });
+    }
+    // Explicit allowlist of tRPC query procedures (GET requests).
+    // Everything else is treated as a mutation (POST).
+    // Source of truth: grep for `.query(` in src/server/api/routers/
+    const QUERY_PROCEDURES = new Set([
+        // billing
+        'billing.getAll', 'billing.getGenerationModels', 'billing.getPackages',
+        'billing.getMonthlyPackages', 'billing.get', 'billing.getSummary',
+        'billing.canExportWatermarkFree', 'billing.getMargins',
+        'billing.getAllOperations', 'billing.getAllPackages',
+        'billing.getModelMapping', 'billing.getEconomicsSummary',
+        // project
+        'project.getById', 'project.validate', 'project.verify',
+        'project.getFullProject', 'project.list', 'project.getLatestId',
+        'project.listScenePlans', 'project.getUploads', 'project.getUserUploads',
+        // chat
+        'chat.getMessages',
+        // payment
+        'payment.getSubscriptionSummary',
+        // api-key
+        'apiKey.list', 'apiKey.get',
+        // notifications
+        'productUpdates.getUnseen', 'creditNotifications.getUnseen',
+        // integrations
+        'github.getConnection', 'github.listRepos',
+        'figma.getConnectionStatus', 'figma.checkConnection', 'figma.getOAuthUrl',
+        // team
+        'team.getMyTeams', 'team.getMyPendingInvites', 'team.getMyPendingInvitations',
+        // templates & storyboard
+        'templates.getCategories', 'templates.getUserTemplates',
+        'templates.getAll', 'templates.getManyByIds',
+        'storyboard.listTemplates',
+        // brand
+        'brandExtraction.listByUser',
+        // share
+        'share.getProjectShare', 'share.getMyShares',
+        // media
+        'media.getMediaContext', 'media.getUserMediaDefaults',
+        // context
+        'context.list',
+        // recipe
+        'recipe.getByProject', 'recipe.getGeneratedAssets',
+        // render
+        'render.listRenders', 'render.getRenderStatus',
+        // usage
+        'usage.getPromptUsage',
+    ]);
+    const isQuery = QUERY_PROCEDURES.has(procedure);
+    // Build URL with input for GET requests (tRPC format)
+    // tRPC v11 expects input wrapped in {"json": ...} format
+    let url = `${config.apiUrl}/api/trpc/${procedure}`;
+    if (isQuery && input) {
+        const wrappedInput = { json: input };
+        const encodedInput = encodeURIComponent(JSON.stringify(wrappedInput));
+        url += `?input=${encodedInput}`;
+    }
+    let response;
+    try {
+        response = await fetch(url, {
+            method: isQuery ? 'GET' : 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': config.apiKey,
+            },
+            body: isQuery ? undefined : JSON.stringify({ json: input }),
+        });
+    }
+    catch (err) {
+        throw new ApiError('Network error: Unable to connect to server', ErrorCodes.NETWORK, { details: err.message, suggestion: 'Check your internet connection' });
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        throw parseApiError(response.status, response.statusText, text, response.headers);
+    }
+    const json = await response.json();
+    // tRPC returns nested format: { result: { data: { json: ... } } }
+    // Or for mutations: { result: { data: ... } }
+    if (json.result?.data?.json !== undefined) {
+        return json.result.data.json;
+    }
+    if (json.result?.data) {
+        return json.result.data;
+    }
+    if (json.json !== undefined) {
+        return json.json;
+    }
+    return json;
+}
+/**
+ * Upload an image and return the URL (backward compatible)
+ */
+export async function uploadImage(config, options) {
+    const result = await uploadMedia(config, {
+        projectId: options.projectId,
+        buffer: options.buffer,
+        filename: options.filename,
+        mimeType: `image/${getFileExtension(options.filename)}`,
+    });
+    return result.url;
+}
+/**
+ * Upload any media file (image, video, audio) and return full result
+ */
+export async function uploadMedia(config, options) {
+    if (!config.apiKey) {
+        throw new ApiError('No API key configured', ErrorCodes.AUTH_MISSING, { suggestion: 'Run: baz auth login <api-key>' });
+    }
+    // Create FormData with file
+    // Convert Buffer to Uint8Array for proper Blob compatibility
+    const formData = new FormData();
+    const uint8Array = new Uint8Array(options.buffer);
+    const blob = new Blob([uint8Array], { type: options.mimeType });
+    formData.append('file', blob, options.filename);
+    formData.append('projectId', options.projectId);
+    let response;
+    try {
+        response = await fetch(`${config.apiUrl}/api/upload`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': config.apiKey,
+            },
+            body: formData,
+        });
+    }
+    catch (err) {
+        throw new ApiError('Network error during upload', ErrorCodes.NETWORK, { details: err.message, suggestion: 'Check your internet connection' });
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        throw parseApiError(response.status, response.statusText, text, response.headers);
+    }
+    const result = await response.json();
+    return result;
+}
+function getFileExtension(filename) {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    return ext || 'png';
+}
+/**
+ * Validate URL is safe to fetch (basic SSRF protection)
+ */
+function isUrlSafe(urlString) {
+    try {
+        const parsed = new URL(urlString);
+        // Only allow http/https
+        if (!['http:', 'https:'].includes(parsed.protocol)) {
+            return false;
+        }
+        // Block private/internal IP ranges
+        const hostname = parsed.hostname.toLowerCase();
+        const blockedPatterns = [
+            'localhost',
+            '127.0.0.1',
+            '0.0.0.0',
+            '10.',
+            '172.16.', '172.17.', '172.18.', '172.19.',
+            '172.20.', '172.21.', '172.22.', '172.23.',
+            '172.24.', '172.25.', '172.26.', '172.27.',
+            '172.28.', '172.29.', '172.30.', '172.31.',
+            '192.168.',
+            '169.254.',
+            '[::1]',
+            '.local',
+            '.internal',
+        ];
+        for (const pattern of blockedPatterns) {
+            if (hostname.includes(pattern) || hostname.startsWith(pattern)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Fetch a URL and extract content (for --url flag)
+ */
+export async function fetchUrlContent(url) {
+    // Security: validate URL before fetching
+    if (!isUrlSafe(url)) {
+        throw new ApiError('URL not allowed', ErrorCodes.VALIDATION, { details: 'Only public HTTP/HTTPS URLs are allowed' });
+    }
+    let response;
+    try {
+        // Create abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 30000); // 30s timeout
+        response = await fetch(url, {
+            headers: {
+                'User-Agent': 'BazaarCLI/1.0 (https://bazaar.it)',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            },
+            signal: controller.signal,
+            redirect: 'follow', // Follow redirects (default max 20)
+        });
+        clearTimeout(timeoutId);
+    }
+    catch (err) {
+        const errorMsg = err.name === 'AbortError'
+            ? 'Request timed out (30s limit)'
+            : err.message;
+        throw new ApiError(`Failed to fetch URL: ${url}`, ErrorCodes.NETWORK, { details: errorMsg });
+    }
+    if (!response.ok) {
+        throw new ApiError(`URL returned error: ${response.status} ${response.statusText}`, ErrorCodes.UNKNOWN, { details: `Failed to fetch: ${url}` });
+    }
+    const contentType = response.headers.get('content-type') || '';
+    // Limit content size (1MB max)
+    const contentLength = response.headers.get('content-length');
+    if (contentLength && parseInt(contentLength, 10) > 1024 * 1024) {
+        throw new ApiError('URL content too large', ErrorCodes.VALIDATION, { details: 'Maximum content size is 1MB' });
+    }
+    const text = await response.text();
+    // Determine content type
+    let type = 'unknown';
+    if (contentType.includes('text/html')) {
+        type = 'html';
+    }
+    else if (contentType.includes('application/json')) {
+        type = 'json';
+    }
+    else if (contentType.includes('text/')) {
+        type = 'text';
+    }
+    // Try to extract title from HTML
+    let title;
+    if (type === 'html') {
+        const titleMatch = text.match(/<title[^>]*>([^<]+)<\/title>/i);
+        if (titleMatch) {
+            title = titleMatch[1].trim();
+        }
+    }
+    return { content: text, title, type };
+}
+/**
+ * Stream a generation request (SSE)
+ */
+export async function streamGeneration(config, options) {
+    if (!config.apiKey) {
+        throw new Error('No API key configured. Run: baz auth login');
+    }
+    const mode = options.mode || 'agent';
+    const agentMode = mode === 'agent' || mode === 'agent-max';
+    const response = await fetch(`${config.apiUrl}/api/generate-stream`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': config.apiKey,
+        },
+        body: JSON.stringify({
+            message: options.prompt, // Server expects 'message', not 'prompt'
+            projectId: options.projectId,
+            mode,
+            agentMode,
+            imageUrls: options.imageUrls,
+            // Handshake protocol fields
+            planOnly: options.planOnly,
+            requirements: options.requirements,
+            // Budget control
+            ...(options.budgetUsd != null && options.budgetUsd > 0 ? { budgetUsd: options.budgetUsd } : {}),
+            // Model — CLI defaults to Sonnet to keep costs reasonable
+            modelOverride: options.modelOverride || 'claude-sonnet-4-5',
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Stream error: ${response.status} - ${text}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error('No response body');
+    }
+    const decoder = new TextDecoder();
+    let pendingChunk = '';
+    let result = {
+        success: false,
+        scenesCreated: [],
+        scenesUpdated: [],
+        errors: [],
+        continue: true, // Will be set to false when stream ends
+    };
+    const processSSELine = (rawLine) => {
+        const line = rawLine.trim();
+        if (!line.startsWith('data:'))
+            return;
+        const dataStr = line.slice(5).trim();
+        if (!dataStr || dataStr === '[DONE]')
+            return;
+        try {
+            const data = JSON.parse(dataStr);
+            const event = parseStreamEvent(data);
+            // Add timestamp and raw data for bot/debug mode
+            if (options.includeRaw) {
+                event.timestamp = new Date().toISOString();
+                event.raw = data;
+            }
+            if (options.onEvent) {
+                options.onEvent(event);
+            }
+            // Accumulate results
+            if (event.type === 'scene_created') {
+                result.scenesCreated.push(event.sceneId);
+            }
+            if (event.type === 'scene_updated') {
+                result.scenesUpdated.push(event.sceneId);
+            }
+            if (event.type === 'error') {
+                result.errors.push(event.message);
+            }
+            if (event.type === 'complete') {
+                result.success = true;
+                result.summary = event.summary;
+                result.stopReason = event.stopReason;
+            }
+        }
+        catch {
+            // Ignore parse errors for malformed event payloads
+        }
+    };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            pendingChunk += decoder.decode(value, { stream: true });
+            const lines = pendingChunk.split('\n');
+            pendingChunk = lines.pop() || '';
+            for (const line of lines) {
+                processSSELine(line);
+            }
+        }
+        // Process any trailing buffered line if stream ended without newline.
+        if (pendingChunk.trim().length > 0) {
+            processSSELine(pendingChunk);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    // Stream ended - set continue to false
+    result.continue = false;
+    return result;
+}
+/**
+ * Convert a normalized SSE event into the CLI's StreamEvent.
+ * This is a thin mapping layer that preserves backwards compatibility for CLI consumers.
+ *
+ * The `rawData` parameter carries the original SSE payload before the shared parser
+ * normalizes it. We need this because the shared parser intentionally strips fields
+ * like `budgetUsd` on ready events (the web UI doesn't need them), but the CLI does.
+ */
+function normalizedToStreamEvent(event, rawData) {
+    const raw = rawData;
+    switch (event.type) {
+        case 'agent_thinking':
+            return { type: 'thinking', message: event.content };
+        case 'agent_action': {
+            // Map action string to start/complete phase for --events-only filtering
+            const actionStr = event.action || '';
+            const phase = actionStr.includes('start') || actionStr === 'tool_use' ? 'start' : 'complete';
+            return {
+                type: 'tool_use',
+                tool: event.toolName,
+                message: event.message,
+                action: phase,
+                sceneId: event.sceneId,
+                sceneName: event.sceneName,
+            };
+        }
+        case 'agent_tool_input':
+            return { type: 'text', message: '' }; // CLI doesn't display tool input streaming
+        case 'error':
+            return {
+                type: 'error',
+                message: event.error,
+                continue: true, // Error doesn't always mean stop - agent decides
+            };
+        case 'scene_added':
+            return {
+                type: 'scene_created',
+                sceneId: event.sceneId,
+                sceneName: event.sceneName,
+            };
+        case 'scene_updated':
+            return {
+                type: 'scene_updated',
+                sceneId: event.sceneId,
+                sceneName: event.sceneName,
+            };
+        case 'generation_complete': {
+            const budget = event.budget;
+            return {
+                type: 'complete',
+                summary: event.summary,
+                stopReason: event.stopReason,
+                continue: false,
+                ...(budget && {
+                    budget: {
+                        budgetUsd: budget.budgetUsd,
+                        totalBilledUsd: budget.totalBilledUsd,
+                        remainingUsd: budget.remainingUsd,
+                    },
+                }),
+            };
+        }
+        case 'recipe_message':
+            return {
+                type: 'recipe_created',
+                recipeName: event.recipe?.title,
+                recipeDescription: event.description,
+                message: event.description || `Created recipe: ${event.recipe?.title || 'Untitled'}`,
+            };
+        case 'workflow_message':
+            return {
+                type: 'workflow_created',
+                workflowName: event.workflowName,
+                workflowDescription: event.description,
+                message: event.description || `Created workflow: ${event.workflowName || 'Untitled'}`,
+            };
+        case 'assistant_message_chunk':
+            return { type: 'text', message: event.message };
+        case 'ready':
+            // Emit structured ready event — budgetUsd is on raw data (shared parser strips it)
+            return {
+                type: 'ready',
+                budgetUsd: typeof raw?.budgetUsd === 'number' ? raw.budgetUsd : undefined,
+                model: event.modelOverride || undefined,
+            };
+        case 'agent_asset': {
+            // Surface asset generation events for agent consumption
+            const asset = event.asset;
+            return {
+                type: 'asset_generated',
+                assetUrl: asset?.url,
+                assetType: asset?.type,
+                costUsd: asset?.costUsd ?? asset?.estimatedCostUsd,
+                message: asset ? `Generated ${asset.type}: ${asset.name || asset.url}` : 'Asset generated',
+            };
+        }
+        case 'title_updated':
+        case 'sidecar_token':
+        case 'sidecar_complete':
+        case 'sidecar_error':
+        case 'preference_saved':
+        case 'worker_event':
+            // Events not relevant to CLI display — emit as silent text
+            return { type: 'text', message: '' };
+        case 'unknown':
+            return { type: 'text', message: JSON.stringify(event.raw) };
+    }
+}
+function parseStreamEvent(data) {
+    const normalized = parseSSEEvent(data);
+    return normalizedToStreamEvent(normalized, data);
+}