@juspay/neurolink/dist/middleware/wrapLanguageModel.js

The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002

/**
 * Local `wrapLanguageModel`.
 *
 * Upstream is a reduce over the middleware array that returns a model whose
 * `doGenerate` / `doStream` route through `transformParams` and the optional
 * `wrapGenerate` / `wrapStream` hooks. Reproduced here so the middleware
 * factory no longer needs the ai package.
 *
 * The OpenAI-compatible streaming path also uses this wrapper. Other native
 * streaming implementations must opt in explicitly; exposing a middleware
 * option or a model-shaped handle alone does not apply the chain.
 */
const doWrap = (model, middleware) => {
    const transform = async (params, type) => middleware.transformParams
        ? await middleware.transformParams({ type, params, model })
        : params;
    return {
        specificationVersion: "v3",
        provider: middleware.overrideProvider?.({ model }) ?? model.provider,
        modelId: middleware.overrideModelId?.({ model }) ?? model.modelId,
        supportedUrls: middleware.overrideSupportedUrls?.({ model }) ?? model.supportedUrls,
        async doGenerate(params) {
            const transformed = await transform(params, "generate");
            const doGenerate = () => model.doGenerate(transformed);
            const doStream = () => model.doStream(transformed);
            return middleware.wrapGenerate
                ? await middleware.wrapGenerate({
                    doGenerate,
                    doStream,
                    params: transformed,
                    model,
                })
                : await doGenerate();
        },
        async doStream(params) {
            const transformed = await transform(params, "stream");
            const doGenerate = () => model.doGenerate(transformed);
            const doStream = () => model.doStream(transformed);
            return middleware.wrapStream
                ? await middleware.wrapStream({
                    doGenerate,
                    doStream,
                    params: transformed,
                    model,
                })
                : await doStream();
        },
    };
};
export const wrapLanguageModel = ({ model, middleware, }) => (Array.isArray(middleware) ? [...middleware] : [middleware])
    .reverse()
    .reduce((wrapped, m) => doWrap(wrapped, m), model);