@ai2070/l0/dist/adapters/helpers.js

L0: The Missing Reliability Substrate for AI

export async function* toL0Events(stream, extractText) {
    try {
        for await (const chunk of stream) {
            const text = extractText(chunk);
            if (text != null) {
                yield {
                    type: "token",
                    value: text,
                    timestamp: Date.now(),
                };
            }
        }
        yield {
            type: "complete",
            timestamp: Date.now(),
        };
    }
    catch (err) {
        yield {
            type: "error",
            error: err instanceof Error ? err : new Error(String(err)),
            timestamp: Date.now(),
        };
    }
}
export async function* toL0EventsWithMessages(stream, handlers) {
    try {
        for await (const chunk of stream) {
            const text = handlers.extractText(chunk);
            if (text != null) {
                yield {
                    type: "token",
                    value: text,
                    timestamp: Date.now(),
                };
                continue;
            }
            if (handlers.extractMessage) {
                const message = handlers.extractMessage(chunk);
                if (message != null) {
                    yield {
                        type: "message",
                        value: message.value,
                        role: message.role,
                        timestamp: Date.now(),
                    };
                }
            }
        }
        yield {
            type: "complete",
            timestamp: Date.now(),
        };
    }
    catch (err) {
        yield {
            type: "error",
            error: err instanceof Error ? err : new Error(String(err)),
            timestamp: Date.now(),
        };
    }
}
export function createAdapterTokenEvent(value) {
    return {
        type: "token",
        value,
        timestamp: Date.now(),
    };
}
export function createAdapterDoneEvent() {
    return {
        type: "complete",
        timestamp: Date.now(),
    };
}
export function createAdapterErrorEvent(err) {
    return {
        type: "error",
        error: err instanceof Error ? err : new Error(String(err)),
        timestamp: Date.now(),
    };
}
export function createAdapterMessageEvent(value, role) {
    return {
        type: "message",
        value,
        role,
        timestamp: Date.now(),
    };
}
export function createAdapterDataEvent(payload) {
    return {
        type: "data",
        data: payload,
        timestamp: Date.now(),
    };
}
export function createAdapterProgressEvent(progress) {
    return {
        type: "progress",
        progress,
        timestamp: Date.now(),
    };
}
export function createImageEvent(options) {
    const payload = {
        contentType: "image",
        mimeType: options.mimeType ?? "image/png",
        url: options.url,
        base64: options.base64,
        bytes: options.bytes,
        metadata: {
            width: options.width,
            height: options.height,
            seed: options.seed,
            model: options.model,
        },
    };
    if (payload.metadata) {
        payload.metadata = Object.fromEntries(Object.entries(payload.metadata).filter(([_, v]) => v !== undefined));
        if (Object.keys(payload.metadata).length === 0) {
            delete payload.metadata;
        }
    }
    return createAdapterDataEvent(payload);
}
export function createAudioEvent(options) {
    const payload = {
        contentType: "audio",
        mimeType: options.mimeType ?? "audio/mp3",
        url: options.url,
        base64: options.base64,
        bytes: options.bytes,
        metadata: {
            duration: options.duration,
            model: options.model,
        },
    };
    if (payload.metadata) {
        payload.metadata = Object.fromEntries(Object.entries(payload.metadata).filter(([_, v]) => v !== undefined));
        if (Object.keys(payload.metadata).length === 0) {
            delete payload.metadata;
        }
    }
    return createAdapterDataEvent(payload);
}
export function createJsonDataEvent(data, metadata) {
    return createAdapterDataEvent({
        contentType: "json",
        mimeType: "application/json",
        json: data,
        metadata,
    });
}
export async function* toMultimodalL0Events(stream, handlers) {
    try {
        for await (const chunk of stream) {
            if (handlers.extractText) {
                const text = handlers.extractText(chunk);
                if (text != null) {
                    yield createAdapterTokenEvent(text);
                    continue;
                }
            }
            if (handlers.extractData) {
                const data = handlers.extractData(chunk);
                if (data != null) {
                    yield createAdapterDataEvent(data);
                    continue;
                }
            }
            if (handlers.extractProgress) {
                const progress = handlers.extractProgress(chunk);
                if (progress != null) {
                    yield createAdapterProgressEvent(progress);
                    continue;
                }
            }
            if (handlers.extractMessage) {
                const message = handlers.extractMessage(chunk);
                if (message != null) {
                    yield createAdapterMessageEvent(message.value, message.role);
                    continue;
                }
            }
        }
        yield createAdapterDoneEvent();
    }
    catch (err) {
        yield createAdapterErrorEvent(err);
    }
}
//# sourceMappingURL=helpers.js.map