sudo apt-get update

OpenAI lança novo modelo de geração de imagens para APIs

A OpenAI acaba de liberar acesso ao seu modelo mais recente de geração de imagens para desenvolvedores via API. O mesmo modelo que viralizou no ChatGPT agora pode ser integrado em suas aplicações, permitindo criar desde figuras no estilo Ghibli até visualizações fotorrealistas. Se você já brincou com a versão do ChatGPT, agora é hora de implementar isso nos seus projetos, com suporte inclusive para Adobe e Figma.

Entre os recursos mais interessantes, destaca-se o "inpainting" - que permite editar apenas áreas específicas de uma imagem através de máscaras, evitando a necessidade de regenerar toda a imagem quando você quer modificar apenas um detalhe. Além disso, o modelo suporta múltiplos formatos (quadrado, paisagem, retrato), diferentes níveis de qualidade e até transparência para criar imagens com fundo transparente.

// Importando as dependências
const { OpenAI } = require("openai");
const fs = require("fs");

// Configurando o cliente OpenAI
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

async function editarImagemComInpainting() {
  try {
    // Carregando a imagem original e a máscara como streams
    // (A máscara deve ter áreas transparentes onde preservar e áreas brancas onde editar)
    const imagem = fs.createReadStream("imagem_original.png");
    const mascara = fs.createReadStream("mascara.png");
    
    const resultado = await openai.images.edit({
      model: "gpt-image-1",
      image: imagem,
      mask: mascara,
      prompt: "Um gato laranja sentado com um chapéu azul",
      n: 1,
      size: "1024x1024",
      response_format: "url" 
    });
    
    console.log("Imagem gerada:", resultado.data[0].url);
  } catch (erro) {
    console.error("Erro ao editar imagem:", erro);
  }
}

editarImagemComInpainting();

A precificação do modelo GPT-image-1 é baseada em tokens, com valores diferentes para entrada e saída:

Na prática, isso se traduz nos seguintes custos aproximados por imagem gerada:

Para prompts mais complexos, o tempo de processamento pode chegar a 2 minutos. Vale notar que o modelo ainda tem algumas limitações: pode ter dificuldades com posicionamento preciso de textos e manter consistência visual para personagens recorrentes em múltiplas gerações.

Node.js 22.15.0 (LTS) lançado com suporte a ZSTD e melhorias no Crypto

O Node.js lançou ontem sua mais recente versão LTS (22.15.0), trazendo várias melhorias notáveis, incluindo suporte para compressão ZSTD, recursos avançados para manipulação de certificados TLS, e melhorias nas APIs de criptografia. Esta versão continua o compromisso da equipe com desempenho e segurança.

1. Suporte para compressão ZSTD

Um dos destaques é a adição de suporte para ZSTD (Zstandard), um algoritmo de compressão de dados rápido desenvolvido pelo Facebook que oferece alta taxa de compressão com desempenho superior ao GZIP em muitos casos.

// Exemplo de uso do ZSTD
const zlib = require('node:zlib');
const fs = require('node:fs');

// Compressão
const input = fs.readFileSync('arquivo.txt');
const compressed = zlib.zstdCompressSync(input);
fs.writeFileSync('arquivo.zst', compressed);

// Descompressão
const compressedData = fs.readFileSync('arquivo.zst');
const decompressed = zlib.zstdDecompressSync(compressedData);
console.log(decompressed.toString());

Este recurso é especialmente útil para aplicações que precisam transferir ou armazenar grandes volumes de dados com eficiência.

2. Melhorias na API de Certificados TLS

A nova versão traz o método tls.getCACertificates() que permite recuperar programaticamente os certificados CA disponíveis no Node.js. Além disso, há suporte para usar certificados do sistema operacional com a flag --use-system-ca, agora disponível também no Windows e macOS:

const tls = require('node:tls');

// Obter todos os certificados CA usados pelo Node.js
const caCerts = tls.getCACertificates();
console.log(`Total de certificados CA: ${caCerts.length}`);

// Acessar informações do primeiro certificado
if (caCerts.length > 0) {
  console.log(`Emissor: ${caCerts[0].issuer.CN}`);
  console.log(`Validade: ${caCerts[0].valid_to}`);
}

Para usar certificados do sistema, você pode iniciar sua aplicação com:

node --use-system-ca app.js

3. Suporte para TLSA em DNS

A versão 22.15.0 adiciona suporte para consulta e análise de registros TLSA, um recurso essencial para DANE (DNS-based Authentication of Named Entities), permitindo verificar certificados TLS através do DNS:

const dns = require('node:dns');
const { promisify } = require('node:util');

const resolveTlsa = promisify(dns.resolveTlsa);

async function checkTlsaRecords(domain) {
  try {
    const records = await resolveTlsa(domain);
    console.log('TLSA records:', records);
    // Registros incluem: usage, selector, matchingType e certificate
  } catch (err) {
    console.error('Erro ao resolver registros TLSA:', err);
  }
}

checkTlsaRecords('_443._tcp.example.com');

4. Melhorias no Assert para Comparações Parciais

A API assert recebeu uma atualização significativa com a implementação de comparação parcial de erros e melhorias no partialDeepStrictEqual, tornando os testes mais flexíveis:

const assert = require('node:assert');

// Comparando objetos de erro parcialmente
const error = new Error('Mensagem de erro');
error.code = 'ERR_CUSTOM';
error.status = 404;

// Verificar apenas algumas propriedades
assert.throws(
  () => { throw error; },
  {
    message: 'Mensagem de erro',
    code: 'ERR_CUSTOM'
    // Não precisa verificar status ou outras propriedades
  }
);

// Uso de partialDeepStrictEqual
const objeto = { 
  usuario: { nome: 'João', idade: 30 },
  enderecos: [
    { cidade: 'São Paulo', tipo: 'residencial' },
    { cidade: 'Rio de Janeiro', tipo: 'comercial' }
  ]
};

// Verificar apenas partes específicas do objeto
assert.partialDeepStrictEqual(objeto, {
  usuario: { nome: 'João' },
  enderecos: [
    { cidade: 'São Paulo' }
  ]
});

5. Exposição da função diff do Util

Uma novidade que vai facilitar a vida dos desenvolvedores de ferramentas de teste e debugging é a exposição da função diff usada pelos erros de asserção:

const { diff } = require('node:util');

const obj1 = { a: 1, b: 2, c: 3 };
const obj2 = { a: 1, b: 5, d: 4 };

// Gera uma visualização das diferenças entre dois objetos
const resultado = diff(obj1, obj2);
console.log(resultado);
// Saída formatada mostrando as diferenças

O Node.js 22.15.0 traz melhorias significativas em áreas-chave como compressão, segurança e ferramentas de desenvolvimento. Em particular, o novo suporte para ZSTD pode oferecer ganhos de performance em aplicações que lidam com grandes volumes de dados, enquanto as melhorias na API de certificados tornam mais fácil o gerenciamento de segurança TLS.

Se você já está usando a versão 22.x, a atualização é recomendada e deve ser tranquila para a maioria das aplicações. Fonte: Node.js - "Node v22.15.0 (LTS)"

pnpm add quick-tips

• screenshot-to-code - Converte screenshots em código clean HTML/Tailwind/React/Vue. O projeto teve um boom em abril e está recebendo constantes atualizações.

• Google Gemini alcança 350 milhões de usuários mensais: O serviço de IA da Google, Gemini, atingiu a impressionante marca de 350 milhões de usuários ativos mensais globalmente, segundo dados revelados durante o processo antitruste em andamento.

• private-gpt - Interaja com seus documentos usando o poder do GPT, 100% privado, sem vazamento de dados. Perfeito para projetos corporativos onde a privacidade é essencial.

• LLaMA-Factory - Framework unificado para fine-tuning de mais de 100 LLMs e VLMs. Uma ferramenta essencial se você está trabalhando com modelos de linguagem e precisa de personalização

sudo shutdown --reboot=tomorrow

Esta newsletter está em constante desenvolvimento (always beta). Estou aprendendo a cada edição e seu feedback é essencial!

Compartilhe com outros devs que podem gostar e me conte o que achou:

• O que você quer ver nas próximas edições?

• Algum tema específico que devemos abordar?

• Sugestões para melhorar o formato?

Todo pull request de ideias é bem-vindo!