@meuecommerce/frete-adapter-node 0.2.0 → 0.3.0

package/dist/cjs/correiosHttpClient.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCorreiosHttpClient = createCorreiosHttpClient;
+/**
+ * Node implementation of the `CorreiosClient` port using global `fetch`.
+ *
+ * Ports the retry/backoff behavior from the Velo backend:
+ * - `auth-methods.js`  -> `authenticate` (up to 5 tries, fail fast on 4xx)
+ * - `estimate-methods.js` -> `getPrice`/`getTime` (timeout + 2 retries, backoff)
+ *
+ * The only host dependency is `fetch`, injectable for tests.
+ */
+const frete_1 = require("@meuecommerce/frete");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function base64(input) {
+    return Buffer.from(input, "utf-8").toString("base64");
+}
+function createCorreiosHttpClient(options = {}) {
+    const { fetch = globalThis.fetch, baseUrl = frete_1.correiosApiUrl, timeoutMs = 20000, estimateRetries = 2, estimateRetryDelayMs = 500, authRetries = 5, authRetryDelayMs = 1000, logger = console, } = options;
+    if (typeof fetch !== "function") {
+        throw new Error("createCorreiosHttpClient: no fetch available (Node 18+ or pass options.fetch)");
+    }
+    /** Run a fetch with a hard timeout + exponential-backoff retry. */
+    async function fetchWithRetry(url, init) {
+        let lastError;
+        for (let attempt = 0; attempt < estimateRetries; attempt++) {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                return await fetch(url, { ...init, signal: controller.signal });
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt === estimateRetries - 1)
+                    break;
+                await sleep(estimateRetryDelayMs * Math.pow(2, attempt));
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        throw lastError;
+    }
+    async function estimate(path, payload, token, tag) {
+        const url = `${baseUrl}${path}`;
+        const init = {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+        };
+        const response = await fetchWithRetry(url, init);
+        if (response.status === 401) {
+            throw { status: 401, message: "unauthorized" };
+        }
+        if (response.status !== 200 && response.status !== 206) {
+            // Correios returns a structured error body on bad requests; the domain
+            // layer filters these out by `txErro`, so pass it through unchanged.
+            const json = await response.json().catch(() => ({}));
+            logger.warn(`[${tag}] invalid response. status=${response.status} body=${JSON.stringify(json)}`);
+            return json;
+        }
+        return (await response.json());
+    }
+    return {
+        async authenticate(credentials) {
+            const url = `${baseUrl}/token/v1/autentica/cartaopostagem`;
+            let lastError;
+            for (let attempt = 0; attempt < authRetries; attempt++) {
+                try {
+                    const response = await fetch(url, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            accept: "application/json",
+                            Authorization: `Basic ${base64(`${credentials.user}:${credentials.apiKey}`)}`,
+                        },
+                        body: JSON.stringify({ numero: credentials.postcard }),
+                    });
+                    // 4xx come from bad credentials/contract, not transient failures —
+                    // fail fast instead of burning retries (and seconds) on them.
+                    if (response.status >= 400 && response.status < 500) {
+                        throw {
+                            status: response.status,
+                            message: response.status === 401
+                                ? "Erro de autenticação nos correios."
+                                : "Não foi possível autenticar o contrato nos Correios.",
+                        };
+                    }
+                    return (await response.json());
+                }
+                catch (error) {
+                    const status = error?.status;
+                    if (typeof status === "number" && status >= 400 && status < 500)
+                        throw error;
+                    lastError = error;
+                    if (attempt < authRetries - 1) {
+                        await sleep(authRetryDelayMs);
+                    }
+                    else {
+                        // apiKey intentionally omitted from logs — it is a secret.
+                        logger.error("[correios.authenticate]:", error, credentials.user, credentials.postcard);
+                        throw error;
+                    }
+                }
+            }
+            throw lastError;
+        },
+        getPrice(payload, token) {
+            return estimate("/preco/v1/nacional", payload, token, "correios.getPrice");
+        },
+        getTime(payload, token) {
+            return estimate("/prazo/v1/nacional", payload, token, "correios.getTime");
+        },
+    };
+}

package/dist/cjs/envSecretStore.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvSecretStore = void 0;
+class EnvSecretStore {
+    env;
+    prefix;
+    constructor(options = {}) {
+        this.env = options.env ?? process.env;
+        this.prefix = options.prefix ?? "MEUFRETE_";
+    }
+    key(name) {
+        return this.prefix + name.replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase();
+    }
+    async getSecret(name) {
+        const value = this.env[this.key(name)];
+        return value == null || value === "" ? null : value;
+    }
+}
+exports.EnvSecretStore = EnvSecretStore;

package/dist/cjs/inMemorySettingsStore.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySettingsStore = void 0;
+class InMemorySettingsStore {
+    defaults;
+    merchants = new Map();
+    constructor(options) {
+        this.defaults = options.defaults;
+        for (const [id, settings] of Object.entries(options.merchants ?? {})) {
+            this.merchants.set(id, settings);
+        }
+    }
+    /** Add or replace a merchant's settings. */
+    set(instanceId, settings) {
+        this.merchants.set(instanceId, settings);
+    }
+    async getMerchantSettings(instanceId) {
+        return this.merchants.get(instanceId) ?? null;
+    }
+    async getDefaultSettings() {
+        return this.defaults;
+    }
+}
+exports.InMemorySettingsStore = InMemorySettingsStore;

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIBoxDistributor = exports.createOpenAIDimensionEstimator = exports.EnvSecretStore = exports.InMemorySettingsStore = exports.createCorreiosHttpClient = void 0;
+/**
+ * @meuecommerce/frete-adapter-node — Node implementations of @meuecommerce/frete ports.
+ *
+ * Wraps global `fetch` so the shipping core can run outside Velo: on the
+ * Shopify/Fly deployment today, and the MCP server next.
+ */
+var correiosHttpClient_js_1 = require("./correiosHttpClient.js");
+Object.defineProperty(exports, "createCorreiosHttpClient", { enumerable: true, get: function () { return correiosHttpClient_js_1.createCorreiosHttpClient; } });
+var inMemorySettingsStore_js_1 = require("./inMemorySettingsStore.js");
+Object.defineProperty(exports, "InMemorySettingsStore", { enumerable: true, get: function () { return inMemorySettingsStore_js_1.InMemorySettingsStore; } });
+var envSecretStore_js_1 = require("./envSecretStore.js");
+Object.defineProperty(exports, "EnvSecretStore", { enumerable: true, get: function () { return envSecretStore_js_1.EnvSecretStore; } });
+var openAIDimensionEstimator_js_1 = require("./openAIDimensionEstimator.js");
+Object.defineProperty(exports, "createOpenAIDimensionEstimator", { enumerable: true, get: function () { return openAIDimensionEstimator_js_1.createOpenAIDimensionEstimator; } });
+var openAIBoxDistributor_js_1 = require("./openAIBoxDistributor.js");
+Object.defineProperty(exports, "createOpenAIBoxDistributor", { enumerable: true, get: function () { return openAIBoxDistributor_js_1.createOpenAIBoxDistributor; } });

package/dist/cjs/openAIBoxDistributor.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIBoxDistributor = createOpenAIBoxDistributor;
+/**
+ * `ProductBoxDistributor` implemented with OpenAI — the AI that distributes
+ * products into boxes (a second call from the Velo `openAI/box-methods.js`
+ * `aiDistributeProducts`, tool `distribute_products`).
+ *
+ * Best-effort: `packBoxes` validates the output and falls back to the
+ * deterministic distribution, so a bad/failed call never breaks packing. `fetch`
+ * is injectable (Velo passes `wix-fetch`); the API key is passed in.
+ */
+const frete_1 = require("@meuecommerce/frete");
+const DISTRIBUTE_TOOL = {
+    type: "function",
+    function: {
+        name: "distribute_products",
+        description: "Distribui TODOS os produtos nas quantidades EXATAS - NUNCA perca produtos ou invente nomes",
+        parameters: {
+            type: "object",
+            properties: {
+                boxes: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            box: { type: "string", description: "ID EXATO da caixa - NUNCA invente" },
+                            products: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: { name: { type: "string" }, quantity: { type: "number", minimum: 1 } },
+                                    required: ["name", "quantity"],
+                                },
+                            },
+                            dimensions: {
+                                type: "object",
+                                properties: { width: { type: "number" }, height: { type: "number" }, length: { type: "number" } },
+                                required: ["width", "height", "length"],
+                            },
+                        },
+                        required: ["box", "products", "dimensions"],
+                    },
+                },
+            },
+            required: ["boxes"],
+        },
+    },
+};
+function findByName(name, items) {
+    return items.find((i) => i.name === name);
+}
+function createPrompt(products, boxes, dims) {
+    const totalVolume = dims.products.reduce((total, p) => {
+        const product = findByName(p.name, products);
+        return product ? total + (0, frete_1.calculateVolume)(p.length, p.width, p.height) * product.quantity : total;
+    }, 0);
+    const boxLines = boxes
+        .map((box) => {
+        const cap = (0, frete_1.calculateVolume)(box.width, box.height, box.length);
+        const pct = Math.round((totalVolume / cap) * 100);
+        return `• ${box.id ?? box.name} (${box.name}): ${cap}cm³ — ${pct}% ${pct > 80 ? "❌ REJEITADA" : "✅ APROVADA"}`;
+    })
+        .join("\n");
+    const productLines = dims.products
+        .map((p) => {
+        const product = findByName(p.name, products);
+        if (!product)
+            return `• ${p.name}: não encontrado no carrinho`;
+        const vol = (0, frete_1.calculateVolume)(p.length, p.width, p.height);
+        return `• ${p.name}: ${product.quantity}x — ${p.length}×${p.width}×${p.height}cm — total ${vol * product.quantity}cm³`;
+    })
+        .join("\n");
+    return (`Especialista em logística: distribua TODOS os produtos nas caixas.\n\n` +
+        `REGRA: o volume dos produtos numa caixa não pode passar de 80% da capacidade dela.\n` +
+        `Volume total dos produtos: ${totalVolume}cm³\n\n` +
+        `CAIXAS:\n${boxLines}\n\nPRODUTOS:\n${productLines}\n\n` +
+        `PRIORIDADE ABSOLUTA: menor número de caixas = menor custo. Use 1 caixa quando couber; ` +
+        `só use múltiplas se for matematicamente impossível. Use IDs de caixa EXATOS e preserve os nomes e quantidades.\n` +
+        `Responda usando a função 'distribute_products'.`);
+}
+function createOpenAIBoxDistributor(options) {
+    const { apiKey, fetch = globalThis.fetch, model = "gpt-4o-mini", temperature = 0.5, apiUrl = "https://api.openai.com/v1/chat/completions", timeoutMs = 20000, } = options;
+    if (!apiKey)
+        throw new Error("createOpenAIBoxDistributor: apiKey is required");
+    if (typeof fetch !== "function")
+        throw new Error("createOpenAIBoxDistributor: no fetch available");
+    return {
+        async distribute(products, boxes, estimatedDimensions) {
+            const body = {
+                model,
+                messages: [
+                    { role: "system", content: "Você é um especialista em otimização logística. SEMPRE maximize consolidação e minimize número de caixas." },
+                    { role: "user", content: createPrompt(products, boxes, estimatedDimensions) },
+                ],
+                tools: [DISTRIBUTE_TOOL],
+                tool_choice: { type: "function", function: { name: "distribute_products" } },
+                temperature,
+            };
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            let response;
+            try {
+                response = await fetch(apiUrl, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!response.ok)
+                throw new Error(`OpenAI API Error: ${response.status} ${response.statusText}`);
+            const json = (await response.json());
+            if (json.error)
+                throw new Error(`OpenAI Error: ${json.error.message}`);
+            const args = json.choices?.[0]?.message?.tool_calls?.[0]?.function?.arguments;
+            if (!args)
+                throw new Error("IA não conseguiu distribuir os produtos");
+            return JSON.parse(args);
+        },
+    };
+}

package/dist/cjs/openAIDimensionEstimator.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIDimensionEstimator = createOpenAIDimensionEstimator;
+const ESTIMATE_DIMENSIONS_TOOL = {
+    type: "function",
+    function: {
+        name: "estimate_dimensions",
+        description: "Estima dimensões de produtos PRESERVANDO os nomes exatos fornecidos",
+        parameters: {
+            type: "object",
+            properties: {
+                products: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            length: { type: "number", description: "Comprimento em cm" },
+                            width: { type: "number", description: "Largura em cm" },
+                            height: { type: "number", description: "Altura em cm" },
+                        },
+                        required: ["name", "length", "width", "height"],
+                    },
+                },
+            },
+            required: ["products"],
+        },
+    },
+};
+function largestBox(boxes) {
+    return boxes.reduce((largest, current) => current.width * current.height * current.length > largest.width * largest.height * largest.length ? current : largest);
+}
+function createPrompt(products, boxes, samples) {
+    const box = largestBox(boxes);
+    const maxWidth = Math.floor(box.width * 0.8);
+    const maxHeight = Math.floor(box.height * 0.8);
+    const maxLength = Math.floor(box.length * 0.8);
+    const samplesSection = samples.length > 0
+        ? `\n🌟 EXEMPLOS DO USUÁRIO (PRIORIDADE MÁXIMA):\n${samples.map((s, i) => `${i + 1}. ${s}`).join("\n")}\n\n` +
+            `📋 INSTRUÇÕES:\n1. Para cada produto, procure um exemplo similar acima\n2. Match exato → use dimensões EXATAS\n3. Similar → ajuste\n4. Sem match → conhecimento geral\n`
+        : `\n📋 INSTRUÇÕES (SEM EXEMPLOS):\n1. Considere a embalagem comercial típica brasileira\n2. Use conhecimento sobre produtos similares\n3. Ajuste baseado no peso\n`;
+    return (`Você é um especialista em dimensões de produtos brasileiros para e-commerce.\n\n` +
+        `🚨 LIMITES FÍSICOS OBRIGATÓRIOS:\n- Largura máxima: ${maxWidth}cm\n- Altura máxima: ${maxHeight}cm\n- Comprimento máximo: ${maxLength}cm\n(Maior caixa: ${box.name ?? "—"})\n\n` +
+        `📦 PRODUTOS PARA ESTIMAR:\n${products.map((p, i) => `${i + 1}. ${p.name} - ${p.quantity}x (${p.weight}kg cada)`).join("\n")}\n` +
+        samplesSection +
+        `\n⚠️ REGRAS: respeite os limites; preserve os nomes EXATOS; retorne length×width×height em cm.\n` +
+        `Responda usando a função 'estimate_dimensions'.`);
+}
+/** Apply the largest-box physical limits + a minimum-volume floor to AI output. */
+function validateAndOptimize(aiResult, products, boxes) {
+    const box = largestBox(boxes);
+    const maxWidth = Math.floor(box.width * 0.8);
+    const maxHeight = Math.floor(box.height * 0.8);
+    const maxLength = Math.floor(box.length * 0.8);
+    const optimized = aiResult.products.map((product) => {
+        let { length, width, height } = product;
+        if (length > maxLength)
+            length = maxLength;
+        if (width > maxWidth)
+            width = maxWidth;
+        if (height > maxHeight)
+            height = maxHeight;
+        const volume = length * width * height;
+        const original = products.find((p) => p.name === product.name);
+        const minVolume = (original?.weight || 0.1) * 500;
+        if (volume > 0 && volume < minVolume) {
+            const scale = Math.cbrt(minVolume / volume);
+            length = Math.min(maxLength, length * scale);
+            width = Math.min(maxWidth, width * scale);
+            height = Math.min(maxHeight, height * scale);
+        }
+        return {
+            name: product.name,
+            length: Math.round(length * 10) / 10,
+            width: Math.round(width * 10) / 10,
+            height: Math.round(height * 10) / 10,
+        };
+    });
+    return { products: optimized };
+}
+function createOpenAIDimensionEstimator(options) {
+    const { apiKey, fetch = globalThis.fetch, model = "gpt-4o-mini", temperature = 0.1, apiUrl = "https://api.openai.com/v1/chat/completions", timeoutMs = 20000, } = options;
+    if (!apiKey)
+        throw new Error("createOpenAIDimensionEstimator: apiKey is required");
+    if (typeof fetch !== "function")
+        throw new Error("createOpenAIDimensionEstimator: no fetch available");
+    return {
+        async estimate(products, boxes, productSamples = []) {
+            if (!boxes.length)
+                throw new Error("estimate: no boxes provided");
+            const body = {
+                model,
+                messages: [
+                    {
+                        role: "system",
+                        content: "Você é um especialista em dimensões de produtos. Use os exemplos personalizados como prioridade máxima quando o nome bater.",
+                    },
+                    { role: "user", content: createPrompt(products, boxes, productSamples) },
+                ],
+                tools: [ESTIMATE_DIMENSIONS_TOOL],
+                tool_choice: { type: "function", function: { name: "estimate_dimensions" } },
+                temperature,
+            };
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            let response;
+            try {
+                response = await fetch(apiUrl, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!response.ok)
+                throw new Error(`OpenAI API Error: ${response.status} ${response.statusText}`);
+            const json = (await response.json());
+            if (json.error)
+                throw new Error(`OpenAI Error: ${json.error.message}`);
+            const args = json.choices?.[0]?.message?.tool_calls?.[0]?.function?.arguments;
+            if (!args)
+                throw new Error("IA não conseguiu estimar dimensões dos produtos");
+            const parsed = JSON.parse(args);
+            return validateAndOptimize(parsed, products, boxes);
+        },
+    };
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/index.d.ts

@@ -12,3 +12,5 @@ export { EnvSecretStore } from "./envSecretStore.js";
 export type { EnvSecretStoreOptions } from "./envSecretStore.js";
 export { createOpenAIDimensionEstimator } from "./openAIDimensionEstimator.js";
 export type { OpenAIDimensionEstimatorOptions } from "./openAIDimensionEstimator.js";
+export { createOpenAIBoxDistributor } from "./openAIBoxDistributor.js";
+export type { OpenAIBoxDistributorOptions } from "./openAIBoxDistributor.js";

package/dist/index.js

@@ -8,3 +8,4 @@ export { createCorreiosHttpClient } from "./correiosHttpClient.js";
 export { InMemorySettingsStore } from "./inMemorySettingsStore.js";
 export { EnvSecretStore } from "./envSecretStore.js";
 export { createOpenAIDimensionEstimator } from "./openAIDimensionEstimator.js";
+export { createOpenAIBoxDistributor } from "./openAIBoxDistributor.js";

package/dist/openAIBoxDistributor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `ProductBoxDistributor` implemented with OpenAI — the AI that distributes
+ * products into boxes (a second call from the Velo `openAI/box-methods.js`
+ * `aiDistributeProducts`, tool `distribute_products`).
+ *
+ * Best-effort: `packBoxes` validates the output and falls back to the
+ * deterministic distribution, so a bad/failed call never breaks packing. `fetch`
+ * is injectable (Velo passes `wix-fetch`); the API key is passed in.
+ */
+import { type ProductBoxDistributor } from "@meuecommerce/frete";
+type FetchLike = typeof globalThis.fetch;
+export interface OpenAIBoxDistributorOptions {
+    apiKey: string;
+    fetch?: FetchLike;
+    model?: string;
+    temperature?: number;
+    apiUrl?: string;
+    timeoutMs?: number;
+}
+export declare function createOpenAIBoxDistributor(options: OpenAIBoxDistributorOptions): ProductBoxDistributor;
+export {};

package/dist/openAIBoxDistributor.js

@@ -0,0 +1,122 @@
+/**
+ * `ProductBoxDistributor` implemented with OpenAI — the AI that distributes
+ * products into boxes (a second call from the Velo `openAI/box-methods.js`
+ * `aiDistributeProducts`, tool `distribute_products`).
+ *
+ * Best-effort: `packBoxes` validates the output and falls back to the
+ * deterministic distribution, so a bad/failed call never breaks packing. `fetch`
+ * is injectable (Velo passes `wix-fetch`); the API key is passed in.
+ */
+import { calculateVolume, } from "@meuecommerce/frete";
+const DISTRIBUTE_TOOL = {
+    type: "function",
+    function: {
+        name: "distribute_products",
+        description: "Distribui TODOS os produtos nas quantidades EXATAS - NUNCA perca produtos ou invente nomes",
+        parameters: {
+            type: "object",
+            properties: {
+                boxes: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            box: { type: "string", description: "ID EXATO da caixa - NUNCA invente" },
+                            products: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: { name: { type: "string" }, quantity: { type: "number", minimum: 1 } },
+                                    required: ["name", "quantity"],
+                                },
+                            },
+                            dimensions: {
+                                type: "object",
+                                properties: { width: { type: "number" }, height: { type: "number" }, length: { type: "number" } },
+                                required: ["width", "height", "length"],
+                            },
+                        },
+                        required: ["box", "products", "dimensions"],
+                    },
+                },
+            },
+            required: ["boxes"],
+        },
+    },
+};
+function findByName(name, items) {
+    return items.find((i) => i.name === name);
+}
+function createPrompt(products, boxes, dims) {
+    const totalVolume = dims.products.reduce((total, p) => {
+        const product = findByName(p.name, products);
+        return product ? total + calculateVolume(p.length, p.width, p.height) * product.quantity : total;
+    }, 0);
+    const boxLines = boxes
+        .map((box) => {
+        const cap = calculateVolume(box.width, box.height, box.length);
+        const pct = Math.round((totalVolume / cap) * 100);
+        return `• ${box.id ?? box.name} (${box.name}): ${cap}cm³ — ${pct}% ${pct > 80 ? "❌ REJEITADA" : "✅ APROVADA"}`;
+    })
+        .join("\n");
+    const productLines = dims.products
+        .map((p) => {
+        const product = findByName(p.name, products);
+        if (!product)
+            return `• ${p.name}: não encontrado no carrinho`;
+        const vol = calculateVolume(p.length, p.width, p.height);
+        return `• ${p.name}: ${product.quantity}x — ${p.length}×${p.width}×${p.height}cm — total ${vol * product.quantity}cm³`;
+    })
+        .join("\n");
+    return (`Especialista em logística: distribua TODOS os produtos nas caixas.\n\n` +
+        `REGRA: o volume dos produtos numa caixa não pode passar de 80% da capacidade dela.\n` +
+        `Volume total dos produtos: ${totalVolume}cm³\n\n` +
+        `CAIXAS:\n${boxLines}\n\nPRODUTOS:\n${productLines}\n\n` +
+        `PRIORIDADE ABSOLUTA: menor número de caixas = menor custo. Use 1 caixa quando couber; ` +
+        `só use múltiplas se for matematicamente impossível. Use IDs de caixa EXATOS e preserve os nomes e quantidades.\n` +
+        `Responda usando a função 'distribute_products'.`);
+}
+export function createOpenAIBoxDistributor(options) {
+    const { apiKey, fetch = globalThis.fetch, model = "gpt-4o-mini", temperature = 0.5, apiUrl = "https://api.openai.com/v1/chat/completions", timeoutMs = 20000, } = options;
+    if (!apiKey)
+        throw new Error("createOpenAIBoxDistributor: apiKey is required");
+    if (typeof fetch !== "function")
+        throw new Error("createOpenAIBoxDistributor: no fetch available");
+    return {
+        async distribute(products, boxes, estimatedDimensions) {
+            const body = {
+                model,
+                messages: [
+                    { role: "system", content: "Você é um especialista em otimização logística. SEMPRE maximize consolidação e minimize número de caixas." },
+                    { role: "user", content: createPrompt(products, boxes, estimatedDimensions) },
+                ],
+                tools: [DISTRIBUTE_TOOL],
+                tool_choice: { type: "function", function: { name: "distribute_products" } },
+                temperature,
+            };
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            let response;
+            try {
+                response = await fetch(apiUrl, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!response.ok)
+                throw new Error(`OpenAI API Error: ${response.status} ${response.statusText}`);
+            const json = (await response.json());
+            if (json.error)
+                throw new Error(`OpenAI Error: ${json.error.message}`);
+            const args = json.choices?.[0]?.message?.tool_calls?.[0]?.function?.arguments;
+            if (!args)
+                throw new Error("IA não conseguiu distribuir os produtos");
+            return JSON.parse(args);
+        },
+    };
+}

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@meuecommerce/frete-adapter-node",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Node implementation of @meuecommerce/frete ports (Correios HTTP client) using global fetch. Used by the Shopify/Fly deployment and the MCP server.",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
     }
   },
   "files": [
@@ -18,7 +20,7 @@
     "node": ">=18.18"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node ../../scripts/cjs-pkg.cjs",
     "prepublishOnly": "npm run build",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
@@ -29,6 +31,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@meuecommerce/frete": "^0.2.0"
-  }
+    "@meuecommerce/frete": "^0.3.0"
+  },
+  "module": "./dist/index.js"
 }