@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.1

package/dist/lib/ai-gateway.js

@@ -1,382 +1,6 @@
-import * as http from 'node:http';
-import * as https from 'node:https';
-import { URL } from 'node:url';
-import { AI_DEFAULT_TIMEOUT_MS, AI_DEFAULT_WORKSPACE_NAME, resolveAiCredentials } from './ai-config.js';
-import { AiStreamParser } from './ai-stream-parser.js';
-import { dialogueEndpoint, dialogueMessagesEndpoint, dialoguesEndpoint, integrationEndpoint, integrationsEndpoint, normalizeAiDialogue, normalizeAiIntegration, normalizeAiIntegrationList, normalizeAiOrganizationQuota, normalizeAiWorkspace, normalizeAiWorkspaceList, normalizeAiWorkspaceMember, quotaEndpoint, workspaceEndpoint, workspaceMembersEndpoint, workspacesEndpoint, } from './ai-types.js';
-import { AI_GATEWAY_EVENT_SERVICE, createTransactionId, gatewayRefererHeaders, gatewayUserAgent, getGatewayTransactionId, scheduleGatewayEventLog, } from './cicd-gateway.js';
-import { formatDebugBody, logVerboseDebug } from './debug.js';
-export class AiGatewayError extends Error {
-    requestMethod;
-    requestUrl;
-    retryAfterSeconds;
-    statusCode;
-    constructor(message, options = {}) {
-        super(message);
-        this.name = 'AiGatewayError';
-        this.requestMethod = options.request?.method;
-        this.requestUrl = options.request?.url;
-        this.retryAfterSeconds = options.retryAfterSeconds;
-        this.statusCode = options.statusCode;
-    }
-}
-function userAgent() {
-    return gatewayUserAgent();
-}
-function transactionIdForRequest() {
-    return getGatewayTransactionId() ?? createTransactionId();
-}
-function parseRetryAfterHeader(value) {
-    if (value === undefined)
-        return undefined;
-    const raw = Array.isArray(value) ? value[0] : value;
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw === 'number')
-        return Number.isFinite(raw) && raw >= 0 ? Math.ceil(raw) : undefined;
-    const trimmed = raw.trim();
-    if (/^\d+$/u.test(trimmed))
-        return Number.parseInt(trimmed, 10);
-    const dateMs = Date.parse(trimmed);
-    return Number.isNaN(dateMs) ? undefined : Math.max(0, Math.ceil((dateMs - Date.now()) / 1000));
-}
-function extractErrorMessage(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        for (const value of [parsed.detail, parsed.message, parsed.error, parsed.title]) {
-            if (typeof value === 'string' && value.trim().length > 0)
-                return value.trim();
-        }
-    }
-    catch {
-        return raw.trim().length > 0 ? raw.trim() : undefined;
-    }
-    return undefined;
-}
-function sanitizeAiErrorMessage(value) {
-    return value
-        .replaceAll(/"((?:apiKey|api_key|password|secret|token))"\s*:\s*"[^"]*"/giu, '"$1":"<masked>"')
-        .replaceAll(/((?:apiKey|api_key|password|secret|token)\s*[=:]\s*)\S+/giu, '$1<masked>');
-}
-function statusMessage(status, raw, retryAfterSeconds) {
-    if (status === 401)
-        return 'Invalid or expired AI token. Run `agentia auth set --ai <pak> --ai-domain <domain> --ai-org <org-id>` to re-authenticate.';
-    if (status === 403)
-        return 'AI agent access is forbidden for the configured organization, workspace, or capability.';
-    if (status === 429)
-        return `AI rate limit reached.${retryAfterSeconds === undefined ? '' : ` Retry in ${retryAfterSeconds}s.`}`;
-    if (status >= 500)
-        return 'AI service unavailable. Check status.copado.com.';
-    const extracted = extractErrorMessage(raw);
-    return extracted === undefined ? `AI Gateway request failed (${status}).` : sanitizeAiErrorMessage(extracted);
-}
-function maskSecret(value) {
-    return value.length <= 8 ? '<masked>' : `${value.slice(0, 4)}...${value.slice(-4)}`;
-}
-function maskHeaders(headers) {
-    const masked = { ...headers };
-    if (masked['X-Authorization'] !== undefined)
-        masked['X-Authorization'] = maskSecret(masked['X-Authorization']);
-    return masked;
-}
-function maskRequestBody(value, key) {
-    if (key !== undefined && /api.?key|password|secret|token/iu.test(key))
-        return '<masked>';
-    if (key === undefined && typeof value === 'string')
-        return sanitizeAiErrorMessage(value);
-    if (Array.isArray(value))
-        return value.map((item) => maskRequestBody(item));
-    if (value === null || typeof value !== 'object')
-        return value;
-    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
-        entryKey,
-        maskRequestBody(entryValue, entryKey),
-    ]));
-}
-function withRequestSuffix(message, request) {
-    const suffix = request.url === undefined ? '' : ` Request: ${request.method ?? ''} ${request.url}`.trimEnd();
-    if (suffix.length === 0)
-        return message;
-    return message.endsWith('.') ? `${message} ${suffix}` : `${message}. ${suffix}`;
-}
-function defaultHttpsRequest({ body, headers, method, onData, onStatus, timeoutMs, url, }) {
-    const hasBody = body !== undefined;
-    const payload = hasBody ? JSON.stringify(body) : '';
-    const requestHeaders = {
-        Accept: 'application/json',
-        ...headers,
-    };
-    if (hasBody) {
-        requestHeaders['Content-Type'] = requestHeaders['Content-Type'] ?? 'application/json';
-        requestHeaders['Content-Length'] = Buffer.byteLength(payload).toString();
-    }
-    const transport = url.protocol === 'http:' ? http : https;
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let settled = false;
-        const rejectOnce = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            reject(error);
-        };
-        const req = transport.request({
-            headers: requestHeaders,
-            hostname: url.hostname,
-            method,
-            path: `${url.pathname}${url.search}`,
-            port: url.port.length > 0 ? Number(url.port) : undefined,
-            timeout: timeoutMs,
-        }, (res) => {
-            const status = res.statusCode ?? 0;
-            const shouldParseStream = onData !== undefined && status < 400;
-            res.on('data', (chunk) => {
-                if (!shouldParseStream)
-                    chunks.push(chunk);
-                if (shouldParseStream) {
-                    try {
-                        onData(chunk);
-                    }
-                    catch (error) {
-                        req.destroy();
-                        rejectOnce(error);
-                    }
-                }
-            });
-            res.on('end', () => {
-                if (settled)
-                    return;
-                settled = true;
-                const raw = Buffer.concat(chunks).toString('utf8');
-                onStatus?.(status);
-                if (status >= 400) {
-                    logVerboseDebug('AI response', {
-                        body: maskRequestBody(formatDebugBody(raw)),
-                        status,
-                    });
-                    const retryAfterSeconds = status === 429 ? parseRetryAfterHeader(res.headers['retry-after']) : undefined;
-                    reject(new AiGatewayError(statusMessage(status, raw, retryAfterSeconds), {
-                        retryAfterSeconds,
-                        statusCode: status,
-                    }));
-                    return;
-                }
-                resolve(raw);
-            });
-        });
-        req.on('error', (error) => rejectOnce(error));
-        req.on('timeout', () => {
-            req.destroy(new Error(`AI Gateway request timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
-        });
-        if (hasBody)
-            req.write(payload);
-        req.end();
-    });
-}
-let httpRequestFn = defaultHttpsRequest;
-function requestUrl(request, baseUrl) {
-    return new URL(request.endpoint.replace(/^\/+/u, ''), `${baseUrl}/`);
-}
-function headersForRequest(pat, request, transactionId) {
-    return {
-        Accept: request.responseType === 'ndjson' ? 'application/x-ndjson, application/json' : 'application/json',
-        ...gatewayRefererHeaders(),
-        'User-Agent': userAgent(),
-        'X-Authorization': pat,
-        'x-transaction-id': transactionId,
-    };
-}
-function scheduleAiGatewayEventLog(input) {
-    scheduleGatewayEventLog({
-        ...input,
-        service: AI_GATEWAY_EVENT_SERVICE,
-    });
-}
-async function executeJsonRequest(request, options = {}) {
-    const credentials = resolveAiCredentials(options);
-    const url = requestUrl(request, credentials.baseUrl);
-    const requestInfo = { method: request.method, url: url.toString() };
-    const transactionId = transactionIdForRequest();
-    const headers = headersForRequest(credentials.pak, request, transactionId);
-    let raw;
-    logVerboseDebug('AI request', {
-        body: maskRequestBody(request.body ?? null),
-        headers: maskHeaders(headers),
-        method: request.method,
-        url: url.toString(),
-    });
-    try {
-        scheduleAiGatewayEventLog({
-            eventId: transactionId,
-            method: request.method,
-            orgId: credentials.orgId?.toString(),
-            url: url.toString(),
-        });
-        raw = await httpRequestFn({
-            body: request.body,
-            headers,
-            method: request.method,
-            timeoutMs: options.timeoutMs ?? AI_DEFAULT_TIMEOUT_MS,
-            url,
-        });
-    }
-    catch (error) {
-        if (error instanceof AiGatewayError) {
-            throw new AiGatewayError(withRequestSuffix(error.message, requestInfo), {
-                request: requestInfo,
-                retryAfterSeconds: error.retryAfterSeconds,
-                statusCode: error.statusCode,
-            });
-        }
-        throw error;
-    }
-    logVerboseDebug('AI response', maskRequestBody(formatDebugBody(raw)));
-    if (raw.trim().length === 0)
-        return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        throw new AiGatewayError(withRequestSuffix(`AI Gateway returned non-JSON response: ${raw}`, requestInfo), {
-            request: requestInfo,
-        });
-    }
-}
-async function executeStreamRequest(request, options, onChunk) {
-    const credentials = resolveAiCredentials(options);
-    const url = requestUrl(request, credentials.baseUrl);
-    const requestInfo = { method: request.method, url: url.toString() };
-    const transactionId = transactionIdForRequest();
-    const headers = headersForRequest(credentials.pak, { ...request, responseType: 'ndjson' }, transactionId);
-    const parser = new AiStreamParser();
-    logVerboseDebug('AI request', {
-        body: request.body ?? null,
-        headers: maskHeaders(headers),
-        method: request.method,
-        url: url.toString(),
-    });
-    try {
-        scheduleAiGatewayEventLog({
-            eventId: transactionId,
-            method: request.method,
-            orgId: credentials.orgId?.toString(),
-            url: url.toString(),
-        });
-        await httpRequestFn({
-            body: request.body,
-            headers,
-            method: request.method,
-            onData(chunk) {
-                for (const parsed of parser.push(chunk))
-                    onChunk(parsed);
-            },
-            timeoutMs: options.timeoutMs ?? AI_DEFAULT_TIMEOUT_MS,
-            url,
-        });
-        logVerboseDebug('AI response', { streamed: true });
-        for (const parsed of parser.finish())
-            onChunk(parsed);
-    }
-    catch (error) {
-        if (error instanceof AiGatewayError) {
-            throw new AiGatewayError(withRequestSuffix(error.message, requestInfo), {
-                request: requestInfo,
-                retryAfterSeconds: error.retryAfterSeconds,
-                statusCode: error.statusCode,
-            });
-        }
-        throw error;
-    }
-}
-export class AiGateway {
-    static async createDialogue(input, options = {}) {
-        return normalizeAiDialogue(await executeJsonRequest({
-            body: {
-                assistantId: input.assistantId,
-                name: input.name,
-                workspaceId: input.workspaceId,
-            },
-            endpoint: dialoguesEndpoint(),
-            method: 'POST',
-        }, options));
-    }
-    static async createIntegration(input, options = {}) {
-        return normalizeAiIntegration(await executeJsonRequest({
-            body: input,
-            endpoint: integrationsEndpoint(),
-            method: 'POST',
-        }, options));
-    }
-    static async createWorkspace(input = undefined, options = {}) {
-        return normalizeAiWorkspace(await executeJsonRequest({
-            body: input ?? { name: AI_DEFAULT_WORKSPACE_NAME },
-            endpoint: workspacesEndpoint(),
-            method: 'POST',
-        }, options));
-    }
-    static async createWorkspaceMember(workspaceId, input, options = {}) {
-        return normalizeAiWorkspaceMember(await executeJsonRequest({
-            body: input,
-            endpoint: workspaceMembersEndpoint(workspaceId),
-            method: 'POST',
-        }, options));
-    }
-    static async deleteIntegration(integrationId, options = {}) {
-        await executeJsonRequest({
-            endpoint: integrationEndpoint(integrationId),
-            method: 'DELETE',
-        }, options);
-    }
-    static async getDialogue(dialogueId, options = {}) {
-        return normalizeAiDialogue(await executeJsonRequest({
-            endpoint: dialogueEndpoint(dialogueId),
-            method: 'GET',
-        }, options));
-    }
-    static async getOrganizationQuota(options = {}) {
-        return normalizeAiOrganizationQuota(await executeJsonRequest({
-            endpoint: quotaEndpoint(),
-            method: 'GET',
-        }, options));
-    }
-    static async getWorkspace(workspaceId, options = {}) {
-        return normalizeAiWorkspace(await executeJsonRequest({
-            endpoint: workspaceEndpoint(workspaceId),
-            method: 'GET',
-        }, options));
-    }
-    static async listIntegrations(options = {}) {
-        return normalizeAiIntegrationList(await executeJsonRequest({
-            endpoint: integrationsEndpoint('MEMBER'),
-            method: 'GET',
-        }, options));
-    }
-    static async listWorkspaces(options = {}) {
-        return normalizeAiWorkspaceList(await executeJsonRequest({
-            endpoint: workspacesEndpoint(),
-            method: 'GET',
-        }, options));
-    }
-    static async sendMessage(dialogueId, message, options, onChunk) {
-        await executeStreamRequest({
-            body: message,
-            endpoint: dialogueMessagesEndpoint(dialogueId),
-            method: 'POST',
-            responseType: 'ndjson',
-        }, options, onChunk);
-    }
-    static async updateWorkspace(workspaceId, input, options = {}) {
-        return normalizeAiWorkspace(await executeJsonRequest({
-            body: input,
-            endpoint: workspaceEndpoint(workspaceId),
-            method: 'PATCH',
-        }, options));
-    }
-}
-export function setAiHttpRequestForTests(requestFn) {
-    httpRequestFn = requestFn;
-}
-export function resetAiHttpRequestForTests() {
-    httpRequestFn = defaultHttpsRequest;
-}
-//# sourceMappingURL=ai-gateway.js.map
+import {modules} from './runtime.js';
+const AiGateway = modules["ai-gateway.js"]["AiGateway"]
+const AiGatewayError = modules["ai-gateway.js"]["AiGatewayError"]
+const resetAiHttpRequestForTests = modules["ai-gateway.js"]["resetAiHttpRequestForTests"]
+const setAiHttpRequestForTests = modules["ai-gateway.js"]["setAiHttpRequestForTests"]
+export {AiGateway, AiGatewayError, resetAiHttpRequestForTests, setAiHttpRequestForTests};

package/dist/lib/ai-operations.js

@@ -1,203 +1,4 @@
-import { v4 as uuidv4 } from 'uuid';
-import { normalizeAiDialogueId, normalizeAiWorkspaceId, resolveAiCredentials } from './ai-config.js';
-import { AiGateway, AiGatewayError } from './ai-gateway.js';
-import { assistantIdForAgent, buildDialogueName, dialogueWorkspaceId, enrichAiPrompt, validateAiContext, } from './ai-types.js';
-import { ensureAgentCicdIntegration, } from './credential-sync.js';
-function trimOptional(value) {
-    if (value === undefined)
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? undefined : trimmed;
-}
-function validatePrompt(prompt) {
-    const trimmed = prompt.trim();
-    if (trimmed.length === 0) {
-        throw new Error('AI prompt cannot be empty.');
-    }
-    return prompt;
-}
-function chunkContent(chunk) {
-    return typeof chunk.content === 'string' ? chunk.content : undefined;
-}
-function normalizeFollowup(value) {
-    if (typeof value === 'string' && value.trim().length > 0)
-        return { content: value };
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const record = value;
-    for (const candidate of [record.content, record.question, record.text]) {
-        if (typeof candidate === 'string' && candidate.trim().length > 0)
-            return { content: candidate };
-    }
-    return undefined;
-}
-function normalizeLink(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const record = value;
-    const link = {};
-    if (typeof record.summary === 'string')
-        link.summary = record.summary;
-    if (typeof record.title === 'string')
-        link.title = record.title;
-    if (typeof record.url === 'string')
-        link.url = record.url;
-    return Object.keys(link).length === 0 ? undefined : link;
-}
-function createStreamSummary() {
-    return {
-        completed: false,
-        content: '',
-        followups: [],
-        links: [],
-        statuses: [],
-        warnings: [],
-    };
-}
-function isCompletionChunk(type) {
-    return type === 'done' || type === 'performance' || type === 'stream_complete';
-}
-function applyMetadataChunk(summary, chunk) {
-    if (chunk.type === 'followup') {
-        const followup = normalizeFollowup(chunk.content);
-        if (followup !== undefined)
-            summary.followups.push(followup);
-        return true;
-    }
-    if (chunk.type === 'link') {
-        const link = normalizeLink(chunk.content);
-        if (link !== undefined)
-            summary.links.push(link);
-        return true;
-    }
-    return chunk.type === 'heartbeat';
-}
-function applyStreamChunk(summary, chunk, callbacks) {
-    const content = chunkContent(chunk);
-    if (isCompletionChunk(chunk.type)) {
-        summary.completed = true;
-        return;
-    }
-    if (applyMetadataChunk(summary, chunk))
-        return;
-    if (chunk.type === 'error')
-        throw new AiGatewayError(content ?? 'AI stream returned an error.');
-    if (chunk.type === 'request_id' && content !== undefined) {
-        summary.gatewayRequestId = content;
-        return;
-    }
-    if (chunk.type === 'status' && content !== undefined) {
-        summary.statuses.push(content);
-        callbacks.onStatus?.(content);
-        return;
-    }
-    if (chunk.type === 'thinking' && content !== undefined) {
-        callbacks.onStatus?.(content);
-        return;
-    }
-    if (chunk.type === 'token' && content !== undefined) {
-        summary.content += content;
-        callbacks.onToken?.(content);
-        return;
-    }
-    if (chunk.type === 'warning' && content !== undefined) {
-        summary.warnings.push(content);
-        callbacks.onWarning?.(content);
-    }
-}
-async function trySynchronizeAgentCredential(options, workspaceId) {
-    try {
-        await ensureAgentCicdIntegration(options.agent, workspaceId, options);
-    }
-    catch (error) {
-        if (options.credentialId !== undefined)
-            throw error;
-        return `Copado CICD credential synchronization was skipped: ${error instanceof Error ? error.message : String(error)}`;
-    }
-}
-export async function bootstrapAiDialogue(options) {
-    const assistantId = assistantIdForAgent(options.agent);
-    const dialogueId = trimOptional(options.dialogue);
-    if (dialogueId !== undefined) {
-        const dialogue = await AiGateway.getDialogue(normalizeAiDialogueId(dialogueId), options);
-        const credentialSyncWarning = await trySynchronizeAgentCredential(options, dialogueWorkspaceId(dialogue));
-        return {
-            assistantId,
-            ...(credentialSyncWarning === undefined ? {} : { credentialSyncWarning }),
-            dialogue,
-        };
-    }
-    const credentials = resolveAiCredentials(options);
-    let workspace;
-    if (options.workspace !== undefined) {
-        workspace = { id: normalizeAiWorkspaceId(options.workspace) };
-    }
-    else if (credentials.workspaceId === undefined) {
-        workspace = await AiGateway.createWorkspace(undefined, options);
-    }
-    else {
-        workspace = { id: credentials.workspaceId };
-    }
-    const credentialSyncWarning = await trySynchronizeAgentCredential(options, workspace.id);
-    const dialogue = await AiGateway.createDialogue({
-        assistantId,
-        name: buildDialogueName(options.kind, options.agent),
-        workspaceId: workspace.id,
-    }, options);
-    return {
-        assistantId,
-        ...(credentialSyncWarning === undefined ? {} : { credentialSyncWarning }),
-        dialogue,
-        workspace,
-    };
-}
-export async function runAiAsk(options, callbacks = {}) {
-    validateAiContext({
-        component: options.component,
-        sfOrg: options.sfOrg,
-        userStory: options.userStory,
-        workItem: options.workItem,
-    });
-    const prompt = enrichAiPrompt(validatePrompt(options.prompt), {
-        component: trimOptional(options.component),
-        sfOrg: trimOptional(options.sfOrg),
-        userStory: trimOptional(options.userStory),
-        workItem: trimOptional(options.workItem),
-    });
-    const bootstrap = await bootstrapAiDialogue({
-        ...options,
-        kind: 'ask',
-    });
-    const requestId = uuidv4();
-    const summary = createStreamSummary();
-    if (bootstrap.credentialSyncWarning !== undefined) {
-        summary.warnings.push(bootstrap.credentialSyncWarning);
-        callbacks.onWarning?.(bootstrap.credentialSyncWarning);
-    }
-    await AiGateway.sendMessage(bootstrap.dialogue.id, {
-        assistantId: bootstrap.assistantId,
-        'dev_context': null,
-        integrations: null,
-        prompt,
-        'request_id': requestId,
-        'system_prompt': null,
-    }, options, (chunk) => applyStreamChunk(summary, chunk, callbacks));
-    if (!summary.completed) {
-        throw new AiGatewayError('AI stream ended before stream_complete. Response may be incomplete.');
-    }
-    return {
-        agent: options.agent,
-        assistantId: bootstrap.assistantId,
-        completed: summary.completed,
-        content: summary.content,
-        dialogueId: bootstrap.dialogue.id,
-        followups: summary.followups,
-        gatewayRequestId: summary.gatewayRequestId,
-        links: summary.links,
-        requestId,
-        statuses: summary.statuses,
-        warnings: summary.warnings,
-        workspaceId: bootstrap.workspace?.id ?? bootstrap.dialogue.workspaceId ?? bootstrap.dialogue.workspace_id ?? undefined,
-    };
-}
-//# sourceMappingURL=ai-operations.js.map
+import {modules} from './runtime.js';
+const bootstrapAiDialogue = modules["ai-operations.js"]["bootstrapAiDialogue"]
+const runAiAsk = modules["ai-operations.js"]["runAiAsk"]
+export {bootstrapAiDialogue, runAiAsk};

package/dist/lib/ai-stream-parser.js

@@ -1,59 +1,4 @@
-import { StringDecoder } from 'node:string_decoder';
-export class AiStreamProtocolError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'AiStreamProtocolError';
-    }
-}
-export class AiStreamParser {
-    buffer = '';
-    decoder = new StringDecoder('utf8');
-    finish() {
-        this.buffer += this.decoder.end();
-        const chunks = [];
-        const trailing = this.buffer.trim();
-        this.buffer = '';
-        if (trailing.length > 0) {
-            chunks.push(this.parseLine(trailing));
-        }
-        return chunks;
-    }
-    push(chunk) {
-        this.buffer += typeof chunk === 'string' ? chunk : this.decoder.write(chunk);
-        return this.drainCompleteLines();
-    }
-    drainCompleteLines() {
-        const chunks = [];
-        while (true) {
-            const newlineIndex = this.buffer.search(/\r?\n/u);
-            if (newlineIndex === -1)
-                break;
-            const rawLine = this.buffer.slice(0, newlineIndex);
-            const newlineLength = this.buffer[newlineIndex] === '\r' && this.buffer[newlineIndex + 1] === '\n' ? 2 : 1;
-            this.buffer = this.buffer.slice(newlineIndex + newlineLength);
-            const line = rawLine.trim();
-            if (line.length > 0) {
-                chunks.push(this.parseLine(line));
-            }
-        }
-        return chunks;
-    }
-    parseLine(line) {
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            throw new AiStreamProtocolError(`AI stream returned malformed NDJSON: ${line}`);
-        }
-        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            throw new AiStreamProtocolError('AI stream returned a non-object NDJSON record.');
-        }
-        const { type } = parsed;
-        if (typeof type !== 'string' || type.trim().length === 0) {
-            throw new AiStreamProtocolError('AI stream record did not include a type.');
-        }
-        return parsed;
-    }
-}
-//# sourceMappingURL=ai-stream-parser.js.map
+import {modules} from './runtime.js';
+const AiStreamParser = modules["ai-stream-parser.js"]["AiStreamParser"]
+const AiStreamProtocolError = modules["ai-stream-parser.js"]["AiStreamProtocolError"]
+export {AiStreamParser, AiStreamProtocolError};