jangada-ai 0.1.0 → 1.0.1

package/README.md

@@ -7,7 +7,7 @@ erro, structured output com Zod, tools, streaming e custo em cada resposta.
 Port da lib Python [`jangada-ai`](https://pypi.org/project/jangada-ai/).
 Documentação: [docs.jangada.dev.br](https://docs.jangada.dev.br).
 
-> Versão 0.1.0: núcleo e 8 providers. MCP, agentes, RAG e o resto chegam nas próximas versões (veja o [roadmap de paridade](https://docs.jangada.dev.br/javascript)).
+> Versão 1.0.0: paridade com a lib Python (providers, tools, MCP, agentes, RAG, eval, A2A e mais).
 
 ```bash
 npm install jangada-ai
@@ -29,7 +29,11 @@ console.log(comp.text, comp.cost);
 ```
 
 Providers: `openai`, `azure`, `groq`, `openrouter`, `deepseek`, `anthropic`,
-`gemini`, `vertex`. Exemplos em [`examples/`](examples/).
+`gemini`, `vertex`, `bedrock`, `mistral`, `ollama`.
+
+Subpaths: `jangada-ai/node` (arquivos, `.env`, `serveMcp`, `serveA2a`),
+`jangada-ai/mcp`, `jangada-ai/rag`, `jangada-ai/eval`, `jangada-ai/prebuilt` e
+`jangada-ai/a2a`. Exemplos em [`examples/`](examples/).
 
 ## Desenvolvimento
 

package/dist/a2a/index.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_server = require("../server-C0wyAefS.cjs");
+exports.A2AHandler = require_server.A2AHandler;
+exports.A2aInvalidParamsError = require_server.A2aInvalidParamsError;
+exports.A2aTaskNotCancelableError = require_server.A2aTaskNotCancelableError;
+exports.A2aTaskNotFoundError = require_server.A2aTaskNotFoundError;
+exports.buildA2aHandler = require_server.buildA2aHandler;
+exports.requestContext = require_server.requestContext;
+exports.textFromParts = require_server.textFromParts;

package/dist/a2a/index.d.cts

@@ -0,0 +1,2 @@
+import { C as JsonRpcResponse, S as JsonRpcError, _ as A2aTask, a as requestContext, b as A2aTaskState, c as A2aAgent, d as A2aHistoryStore, f as A2aInvalidParamsError, g as A2aStreamEvent, h as A2aStatusUpdate, i as buildA2aHandler, l as A2aArtifact, m as A2aPart, n as A2aServed, o as A2AHandler, p as A2aMessage, r as A2aServerOptions, s as A2AHandlerOptions, t as A2aRequestContext, u as A2aCallOptions, v as A2aTaskNotCancelableError, w as textFromParts, x as A2aTaskStatus, y as A2aTaskNotFoundError } from "../server-CnO0Uj7X.cjs";
+export { A2AHandler, type A2AHandlerOptions, type A2aAgent, type A2aArtifact, type A2aCallOptions, type A2aHistoryStore, A2aInvalidParamsError, type A2aMessage, type A2aPart, type A2aRequestContext, type A2aServed, type A2aServerOptions, type A2aStatusUpdate, type A2aStreamEvent, type A2aTask, A2aTaskNotCancelableError, A2aTaskNotFoundError, type A2aTaskState, type A2aTaskStatus, type JsonRpcError, type JsonRpcResponse, buildA2aHandler, requestContext, textFromParts };

package/dist/a2a/index.d.ts

@@ -0,0 +1,2 @@
+import { C as JsonRpcResponse, S as JsonRpcError, _ as A2aTask, a as requestContext, b as A2aTaskState, c as A2aAgent, d as A2aHistoryStore, f as A2aInvalidParamsError, g as A2aStreamEvent, h as A2aStatusUpdate, i as buildA2aHandler, l as A2aArtifact, m as A2aPart, n as A2aServed, o as A2AHandler, p as A2aMessage, r as A2aServerOptions, s as A2AHandlerOptions, t as A2aRequestContext, u as A2aCallOptions, v as A2aTaskNotCancelableError, w as textFromParts, x as A2aTaskStatus, y as A2aTaskNotFoundError } from "../server-DVWw6Q6D.js";
+export { A2AHandler, type A2AHandlerOptions, type A2aAgent, type A2aArtifact, type A2aCallOptions, type A2aHistoryStore, A2aInvalidParamsError, type A2aMessage, type A2aPart, type A2aRequestContext, type A2aServed, type A2aServerOptions, type A2aStatusUpdate, type A2aStreamEvent, type A2aTask, A2aTaskNotCancelableError, A2aTaskNotFoundError, type A2aTaskState, type A2aTaskStatus, type JsonRpcError, type JsonRpcResponse, buildA2aHandler, requestContext, textFromParts };

package/dist/a2a/index.js

@@ -0,0 +1 @@
+export { r as A2AHandler, i as A2aInvalidParamsError, a as A2aTaskNotCancelableError, o as A2aTaskNotFoundError, t as buildA2aHandler, n as requestContext, s as textFromParts } from "../server-zdrObsBn.js";

package/dist/{anthropic-D5xT9Yc4.cjs → anthropic-B3YravIz.cjs}

@@ -1,5 +1,8 @@
-const require_base = require("./base-oJ61mpAL.cjs");
-const require_env = require("./env-BgCjpek9.cjs");
+const require_errors = require("./errors-BJIPDLwX.cjs");
+const require_client = require("./client-DgttfmVI.cjs");
+const require_message = require("./message-DCvWw0dF.cjs");
+const require_version = require("./version-cxay-WR-.cjs");
+const require_base = require("./base-DCec5kyg.cjs");
 // src/providers/anthropic.ts
 /**
 * Provider Anthropic (Claude): texto, vision, tools, tools nativas (server tools),
@@ -10,7 +13,8 @@ const require_env = require("./env-BgCjpek9.cjs");
 * Schema. Nos modelos que REJEITAM forced tool use (Opus 5.5, Sonnet 5.5, Fable 5.1,
 * Mythos 5.1) cai para `tool_choice: auto` + strict tool use, a migração oficial.
 *
-* Fica para a Fase 3: MCP remoto (Messages API beta).
+* MCP remoto: `mcpServers` com `MCPServer` vai na Messages API (`mcp_servers` +
+* `mcp_toolset`, header beta `mcp-client-2025-11-20`). Sessão client-side não dá.
 *
 * Espelha `jangada_ai/providers/anthropic.py`.
 */
@@ -18,6 +22,7 @@ const THINKING_KEY = "anthropic_thinking_blocks";
 const CONTENT_KEY = "anthropic_content";
 const CONTAINER_KEY = "anthropic_container";
 const MAX_PAUSE = 5;
+const MCP_BETA = "mcp-client-2025-11-20";
 const NATIVE_VERSIONS = {
 	web_search: ["web_search_20250305", "web_search"],
 	web_fetch: ["web_fetch_20250910", "web_fetch"],
@@ -71,6 +76,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 	]);
 	nativeToolPassthrough = true;
 	nativeToolAliases = ["claude"];
+	supportsMcp = true;
 	async buildClient() {
 		let mod;
 		try {
@@ -97,7 +103,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 			source: {
 				type: "base64",
 				media_type: p.mimeType,
-				data: require_env.imageBase64(p)
+				data: require_message.imageBase64(p)
 			}
 		});
 		else if (p.type === "tool_call") {
@@ -156,7 +162,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		return out;
 	}
 	formatTools(tools) {
-		const { functions, natives } = require_base.splitTools(tools);
+		const { functions, natives } = require_version.splitTools(tools);
 		const out = functions.map((t) => ({
 			name: t.name,
 			description: t.description,
@@ -175,13 +181,13 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		const tipo = o.version ?? tipoPadrao;
 		delete o.version;
 		delete o.container;
-		if (o.files !== void 0) throw new require_base.UnsupportedError("codeExecution({ files }) não existe na Anthropic: envie os arquivos como blocos container_upload (Files API) na mensagem.", { provider: this.name });
+		if (o.files !== void 0) throw new require_errors.UnsupportedError("codeExecution({ files }) não existe na Anthropic: envie os arquivos como blocos container_upload (Files API) na mensagem.", { provider: this.name });
 		const loc = o.user_location;
 		if (loc && typeof loc === "object" && !("type" in loc)) o.user_location = {
 			type: "approximate",
 			...loc
 		};
-		if (o.allowed_domains && o.blocked_domains) throw new require_base.UnsupportedError(`${nt.kind}: a Anthropic não aceita allowedDomains e blockedDomains juntos (400). Use só um.`, { provider: this.name });
+		if (o.allowed_domains && o.blocked_domains) throw new require_errors.UnsupportedError(`${nt.kind}: a Anthropic não aceita allowedDomains e blockedDomains juntos (400). Use só um.`, { provider: this.name });
 		return {
 			type: tipo,
 			name: nome,
@@ -190,7 +196,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 	}
 	/** Container do code_execution: o explícito ou o último do histórico. */
 	static containerFrom(messages, tools) {
-		for (const t of tools) if (t instanceof require_base.NativeTool && t.kind === "code_execution") {
+		for (const t of tools) if (t instanceof require_version.NativeTool && t.kind === "code_execution") {
 			const explicito = t.options.container;
 			if (typeof explicito === "string" && explicito) return explicito;
 			for (const m of [...messages].reverse()) {
@@ -226,14 +232,45 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 			kw.tools = this.formatTools(tools);
 			if (options.toolChoice !== void 0 && options.toolChoice !== null) {
 				const tc = AnthropicProvider.toolChoice(options.toolChoice);
-				if (this.forbidsForcedTools() && (tc.type === "any" || tc.type === "tool")) throw new require_base.UnsupportedError(`${this.model} não suporta forced tool use (toolChoice=${JSON.stringify(options.toolChoice)}): a API retorna 400. Use toolChoice 'auto' (com strict tool use, se quiser garantir o schema) ou structured output via parse().`, { provider: this.name });
+				if (this.forbidsForcedTools() && (tc.type === "any" || tc.type === "tool")) throw new require_errors.UnsupportedError(`${this.model} não suporta forced tool use (toolChoice=${JSON.stringify(options.toolChoice)}): a API retorna 400. Use toolChoice 'auto' (com strict tool use, se quiser garantir o schema) ou structured output via parse().`, { provider: this.name });
 				kw.tool_choice = tc;
 			}
 			const container = AnthropicProvider.containerFrom(messages, tools);
 			if (container) kw.container = container;
 		}
+		if (options.mcpServers?.length) this.applyMcp(kw, options.mcpServers);
 		return kw;
 	}
+	/**
+	* MCP remoto via Messages API (server-side, beta). Sessão client-side não dá.
+	* Allowlist no shape `mcp-client-2025-11-20`: `default_config` desabilitado e cada
+	* tool permitida habilitada em `configs`.
+	*/
+	applyMcp(kw, mcpServers) {
+		const { remote, sessions } = require_client.splitMcp(mcpServers);
+		if (sessions.length) throw new require_errors.UnsupportedError("Anthropic só aceita MCP remoto por URL (passe MCPServer). Para MCP client-side (sessão), use o Gemini ou MCPClient + runAgent.", { provider: this.name });
+		kw.mcp_servers = remote.map((s) => ({
+			type: "url",
+			url: s.url,
+			name: s.name,
+			...s.authorizationToken ? { authorization_token: s.authorizationToken } : {}
+		}));
+		const toolsets = remote.map((s) => ({
+			type: "mcp_toolset",
+			mcp_server_name: s.name,
+			...s.allowedTools?.length ? {
+				default_config: { enabled: false },
+				configs: Object.fromEntries(s.allowedTools.map((t) => [t, { enabled: true }]))
+			} : {}
+		}));
+		kw.tools = [...kw.tools ?? [], ...toolsets];
+	}
+	/** Opções da requisição: `signal` e, com MCP, o header beta. */
+	reqOptions(options) {
+		const o = { signal: options.signal };
+		if (options.mcpServers?.length) o.headers = { "anthropic-beta": MCP_BETA };
+		return o;
+	}
 	static thinkingBlocks(content) {
 		const out = [];
 		for (const b of content) {
@@ -254,8 +291,8 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		try {
 			return this.buildCompletion(resp);
 		} catch (e) {
-			if (e instanceof require_base.LLMError) throw e;
-			throw new require_base.ProviderError(`[${this.name}] resposta em formato inesperado: ${e instanceof Error ? `${e.name}: ${e.message}` : e}`, {
+			if (e instanceof require_errors.LLMError) throw e;
+			throw new require_errors.ProviderError(`[${this.name}] resposta em formato inesperado: ${e instanceof Error ? `${e.name}: ${e.message}` : e}`, {
 				provider: this.name,
 				original: e
 			});
@@ -263,9 +300,9 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 	}
 	buildCompletion(resp) {
 		const content = get(resp, "content");
-		if (!Array.isArray(content)) throw new require_base.ServerError(`[${this.name}] resposta sem conteúdo (content=${content}).`, { provider: this.name });
+		if (!Array.isArray(content)) throw new require_errors.ServerError(`[${this.name}] resposta sem conteúdo (content=${content}).`, { provider: this.name });
 		const text = content.map((b) => get(b, "type") === "text" ? get(b, "text") ?? "" : "").join("");
-		const toolCalls = content.filter((b) => get(b, "type") === "tool_use" && get(b, "name")).map((b) => new require_env.ToolCall(String(get(b, "id") ?? ""), String(get(b, "name")), { ...get(b, "input") ?? {} }));
+		const toolCalls = content.filter((b) => get(b, "type") === "tool_use" && get(b, "name")).map((b) => new require_message.ToolCall(String(get(b, "id") ?? ""), String(get(b, "name")), { ...get(b, "input") ?? {} }));
 		const thinking = AnthropicProvider.thinkingBlocks(content);
 		if (thinking.length && toolCalls[0]) toolCalls[0].metadata[THINKING_KEY] = thinking;
 		const { citations, serverCalls, preservar } = AnthropicProvider.nativeOutputs(content);
@@ -295,7 +332,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 			}
 		}
 		const stop = get(resp, "stop_reason") ?? null;
-		return new require_env.Completion({
+		return new require_message.Completion({
 			text,
 			model: this.model,
 			provider: this.name,
@@ -419,7 +456,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		let resp;
 		for (let i = 0; i <= MAX_PAUSE; i++) {
 			try {
-				resp = await client.messages.create(kw, { signal: options.signal });
+				resp = await client.messages.create(kw, this.reqOptions(options));
 			} catch (e) {
 				throw this.err(e, options);
 			}
@@ -434,7 +471,8 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		const kw = this.kwargs(messages, {
 			...options,
 			tools: void 0,
-			toolChoice: void 0
+			toolChoice: void 0,
+			mcpServers: void 0
 		});
 		const extract = {
 			name: "extract",
@@ -465,7 +503,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		const comp = this.completion(resp);
 		require_base.Provider.checkTruncation(comp, this.name);
 		const toolUse = (get(resp, "content") ?? []).find((b) => get(b, "type") === "tool_use");
-		if (!toolUse) throw new require_base.OutputValidationError(`[${this.name}] o modelo não devolveu o objeto estruturado (stop_reason=${JSON.stringify(comp.finishReason ?? "sem tool_use")}): ${JSON.stringify(comp.text.slice(0, 200))}`, { provider: this.name });
+		if (!toolUse) throw new require_errors.OutputValidationError(`[${this.name}] o modelo não devolveu o objeto estruturado (stop_reason=${JSON.stringify(comp.finishReason ?? "sem tool_use")}): ${JSON.stringify(comp.text.slice(0, 200))}`, { provider: this.name });
 		const input = get(toolUse, "input");
 		comp.text = JSON.stringify(input);
 		comp.parsed = await schema.validate(input);
@@ -483,7 +521,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		let resp;
 		for (let i = 0; i <= MAX_PAUSE; i++) {
 			try {
-				const s = client.messages.stream(kw, { signal: options.signal });
+				const s = client.messages.stream(kw, this.reqOptions(options));
 				for await (const ev of s) {
 					if (get(ev, "type") !== "content_block_delta") continue;
 					const delta = get(ev, "delta");
@@ -511,7 +549,7 @@ var AnthropicProvider = class AnthropicProvider extends require_base.Provider {
 		};
 	}
 	err(e, options) {
-		return options.signal?.aborted ? e : require_base.classify(e, this.name);
+		return options.signal?.aborted ? e : require_errors.classify(e, this.name);
 	}
 };
 exports.AnthropicProvider = AnthropicProvider;

package/dist/{anthropic-BOBKTM1i.js → anthropic-BIf0c9qU.js}

@@ -1,5 +1,8 @@
-import { F as ProviderError, H as classify, N as OutputValidationError, R as ServerError, V as UnsupportedError, d as NativeTool, j as LLMError, n as applyProfile, s as splitTools, t as Provider } from "./base-C-SPiVRW.js";
-import { c as imageBase64, i as Completion, s as ToolCall } from "./env-c3s1IX0t.js";
+import { _ as UnsupportedError, d as ProviderError, l as OutputValidationError, m as ServerError, s as LLMError, v as classify } from "./errors-hp-4UePr.js";
+import { s as splitMcp } from "./client-D2b1IWMA.js";
+import { a as ToolCall, n as Completion, o as imageBase64 } from "./message-0wKCrEp2.js";
+import { c as NativeTool, i as splitTools } from "./version-BR38yiy9.js";
+import { n as applyProfile, t as Provider } from "./base-DINmmIz8.js";
 // src/providers/anthropic.ts
 /**
 * Provider Anthropic (Claude): texto, vision, tools, tools nativas (server tools),
@@ -10,7 +13,8 @@ import { c as imageBase64, i as Completion, s as ToolCall } from "./env-c3s1IX0t
 * Schema. Nos modelos que REJEITAM forced tool use (Opus 5.5, Sonnet 5.5, Fable 5.1,
 * Mythos 5.1) cai para `tool_choice: auto` + strict tool use, a migração oficial.
 *
-* Fica para a Fase 3: MCP remoto (Messages API beta).
+* MCP remoto: `mcpServers` com `MCPServer` vai na Messages API (`mcp_servers` +
+* `mcp_toolset`, header beta `mcp-client-2025-11-20`). Sessão client-side não dá.
 *
 * Espelha `jangada_ai/providers/anthropic.py`.
 */
@@ -18,6 +22,7 @@ const THINKING_KEY = "anthropic_thinking_blocks";
 const CONTENT_KEY = "anthropic_content";
 const CONTAINER_KEY = "anthropic_container";
 const MAX_PAUSE = 5;
+const MCP_BETA = "mcp-client-2025-11-20";
 const NATIVE_VERSIONS = {
 	web_search: ["web_search_20250305", "web_search"],
 	web_fetch: ["web_fetch_20250910", "web_fetch"],
@@ -71,6 +76,7 @@ var AnthropicProvider = class AnthropicProvider extends Provider {
 	]);
 	nativeToolPassthrough = true;
 	nativeToolAliases = ["claude"];
+	supportsMcp = true;
 	async buildClient() {
 		let mod;
 		try {
@@ -232,8 +238,39 @@ var AnthropicProvider = class AnthropicProvider extends Provider {
 			const container = AnthropicProvider.containerFrom(messages, tools);
 			if (container) kw.container = container;
 		}
+		if (options.mcpServers?.length) this.applyMcp(kw, options.mcpServers);
 		return kw;
 	}
+	/**
+	* MCP remoto via Messages API (server-side, beta). Sessão client-side não dá.
+	* Allowlist no shape `mcp-client-2025-11-20`: `default_config` desabilitado e cada
+	* tool permitida habilitada em `configs`.
+	*/
+	applyMcp(kw, mcpServers) {
+		const { remote, sessions } = splitMcp(mcpServers);
+		if (sessions.length) throw new UnsupportedError("Anthropic só aceita MCP remoto por URL (passe MCPServer). Para MCP client-side (sessão), use o Gemini ou MCPClient + runAgent.", { provider: this.name });
+		kw.mcp_servers = remote.map((s) => ({
+			type: "url",
+			url: s.url,
+			name: s.name,
+			...s.authorizationToken ? { authorization_token: s.authorizationToken } : {}
+		}));
+		const toolsets = remote.map((s) => ({
+			type: "mcp_toolset",
+			mcp_server_name: s.name,
+			...s.allowedTools?.length ? {
+				default_config: { enabled: false },
+				configs: Object.fromEntries(s.allowedTools.map((t) => [t, { enabled: true }]))
+			} : {}
+		}));
+		kw.tools = [...kw.tools ?? [], ...toolsets];
+	}
+	/** Opções da requisição: `signal` e, com MCP, o header beta. */
+	reqOptions(options) {
+		const o = { signal: options.signal };
+		if (options.mcpServers?.length) o.headers = { "anthropic-beta": MCP_BETA };
+		return o;
+	}
 	static thinkingBlocks(content) {
 		const out = [];
 		for (const b of content) {
@@ -419,7 +456,7 @@ var AnthropicProvider = class AnthropicProvider extends Provider {
 		let resp;
 		for (let i = 0; i <= MAX_PAUSE; i++) {
 			try {
-				resp = await client.messages.create(kw, { signal: options.signal });
+				resp = await client.messages.create(kw, this.reqOptions(options));
 			} catch (e) {
 				throw this.err(e, options);
 			}
@@ -434,7 +471,8 @@ var AnthropicProvider = class AnthropicProvider extends Provider {
 		const kw = this.kwargs(messages, {
 			...options,
 			tools: void 0,
-			toolChoice: void 0
+			toolChoice: void 0,
+			mcpServers: void 0
 		});
 		const extract = {
 			name: "extract",
@@ -483,7 +521,7 @@ var AnthropicProvider = class AnthropicProvider extends Provider {
 		let resp;
 		for (let i = 0; i <= MAX_PAUSE; i++) {
 			try {
-				const s = client.messages.stream(kw, { signal: options.signal });
+				const s = client.messages.stream(kw, this.reqOptions(options));
 				for await (const ev of s) {
 					if (get(ev, "type") !== "content_block_delta") continue;
 					const delta = get(ev, "delta");

package/dist/base-DCec5kyg.cjs

@@ -0,0 +1,277 @@
+const require_errors = require("./errors-BJIPDLwX.cjs");
+const require_version = require("./version-cxay-WR-.cjs");
+const require_env = require("./env-B1ffNsxb.cjs");
+// src/profiles.ts
+const RULES = [];
+/** Adiciona uma regra de perfil (entra no início: tem prioridade). */
+function registerProfile(provider, pattern, profile) {
+	const rx = pattern instanceof RegExp ? new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, "")) : new RegExp(pattern);
+	RULES.unshift({
+		provider: provider.toLowerCase(),
+		rx,
+		profile
+	});
+}
+const ALIASES = {
+	vertex: "gemini",
+	azure: "openai"
+};
+/** Faz `provider` herdar as regras de perfil de `target`. */
+function registerAlias(provider, target) {
+	ALIASES[provider.toLowerCase()] = target.toLowerCase();
+}
+const has = (o, k) => o[k] !== void 0 && o[k] !== null;
+/**
+* Aplica todas as regras que casam com (provider, model). Devolve uma CÓPIA dos
+* params e os avisos. `profileModel` sobrepõe o nome usado para casar as regras
+* (útil no Azure, onde `model` é o nome do deployment).
+*/
+function applyProfile(provider, model, params, options) {
+	const out = { ...params };
+	const warnings = [];
+	const prov = provider.toLowerCase();
+	const provs = /* @__PURE__ */ new Set([prov, ALIASES[prov] ?? prov]);
+	const alvo = options?.profileModel ?? model;
+	for (const { provider: p, rx, profile } of [...RULES]) {
+		if (!provs.has(p) || !rx.test(alvo)) continue;
+		const note = profile.note ?? "";
+		for (const key of profile.drop ?? []) if (has(out, key)) {
+			delete out[key];
+			warnings.push(`${model}: '${key}' removido (${note})`);
+		}
+		for (const [old, novo] of Object.entries(profile.rename ?? {})) if (has(out, old)) {
+			out[novo] = out[old];
+			delete out[old];
+			warnings.push(`${model}: '${old}' -> '${novo}' (${note})`);
+		}
+		if (profile.transform) warnings.push(...profile.transform(out, alvo));
+	}
+	return {
+		params: out,
+		warnings
+	};
+}
+const LEVEL_TO_BUDGET = {
+	MINIMAL: 0,
+	LOW: 1024,
+	MEDIUM: 8192,
+	HIGH: 24576
+};
+const MIN_BUDGET_25_PRO = 128;
+function gemini3Thinking(params, model) {
+	if (!("thinkingBudget" in params)) return [];
+	const budget = params.thinkingBudget;
+	delete params.thinkingBudget;
+	if (!has(params, "thinkingLevel")) {
+		let level;
+		if (!budget || budget < 0 || budget <= 1024) level = "LOW";
+		else if (budget <= 8192 && model.toLowerCase().includes("flash")) level = "MEDIUM";
+		else level = "HIGH";
+		params.thinkingLevel = level;
+	}
+	return [`thinkingBudget -> thinkingLevel='${params.thinkingLevel}' (Gemini 3.x não aceita budget)`];
+}
+function gemini25Thinking(params, model) {
+	if (!("thinkingLevel" in params)) return [];
+	const level = String(params.thinkingLevel).toUpperCase();
+	delete params.thinkingLevel;
+	if (!has(params, "thinkingBudget")) {
+		let budget = LEVEL_TO_BUDGET[level] ?? -1;
+		if (budget === 0 && /2\.5-pro/.test(model)) budget = MIN_BUDGET_25_PRO;
+		params.thinkingBudget = budget;
+	}
+	return [`thinkingLevel='${level}' -> thinkingBudget=${params.thinkingBudget} (Gemini 2.5 não aceita level)`];
+}
+const OPENAI_REASONING_DROP = [
+	"temperature",
+	"top_p",
+	"presence_penalty",
+	"frequency_penalty",
+	"logprobs",
+	"logit_bias",
+	"n"
+];
+registerProfile("openai", /^gpt-(?:[5-9]|[1-9]\d)(?!\d)(?!.*chat)/, {
+	drop: OPENAI_REASONING_DROP,
+	rename: { max_tokens: "max_completion_tokens" },
+	note: "modelo de raciocínio gpt-5+"
+});
+registerProfile("openai", /^o[134](-|$)/, {
+	drop: OPENAI_REASONING_DROP,
+	rename: { max_tokens: "max_completion_tokens" },
+	note: "modelo de raciocínio série o"
+});
+registerProfile("gemini", /gemini-(?:[3-9]|[1-9]\d)(?!\d)/, {
+	drop: [
+		"temperature",
+		"topP",
+		"topK",
+		"candidateCount"
+	],
+	transform: gemini3Thinking,
+	note: "Gemini 3.x+/4 usa defaults de sampling"
+});
+registerProfile("gemini", /gemini-2\.5/, {
+	transform: gemini25Thinking,
+	note: "Gemini 2.5 usa thinkingBudget"
+});
+// src/providers/base.ts
+/**
+* Contrato base do provider: texto, structured output e streaming (tudo async).
+* Espelha `jangada_ai/providers/base.py`, sem as versões sync.
+*
+* Invariantes para quem escreve um adapter:
+* - o SDK só entra via `await import()` dentro de `buildClient()`;
+* - toda chamada ao SDK fica em try/catch e relança com `classify(e, this.name)`;
+* - params: `translate()` (canônico → nativo) e depois `applyProfile()`.
+*/
+var Provider = class {
+	/** Variável de ambiente com a chave, usada quando `apiKey` não é passado. */
+	envKey = null;
+	/** Tipos canônicos que o adapter sabe traduzir (`web_search`, `code_execution`...). */
+	nativeToolKinds = /* @__PURE__ */ new Set();
+	/** Aceita `nativeTool(<este provider>, spec)` (payload nativo repassado cru)? */
+	nativeToolPassthrough = false;
+	/** Nomes extras aceitos em `nativeTool(provider, ...)` além de `name`. */
+	nativeToolAliases = [];
+	/** `parse()` aceita tools nativas junto? */
+	nativeToolsWithParse = false;
+	/** Aceita `mcpServers` em `complete`/`streamComplete`? */
+	supportsMcp = false;
+	model;
+	apiKey;
+	profileModel;
+	clientOptions;
+	clientPromise = null;
+	constructor(model, options = {}) {
+		this.model = model;
+		this.apiKey = options.apiKey;
+		this.profileModel = options.profileModel;
+		this.clientOptions = { ...options.clientOptions ?? {} };
+	}
+	/**
+	* Valida as tools NATIVAS antes de ir ao SDK: tipo não suportado, `nativeTool()`
+	* de outro provider ou `parse()` com nativas onde a API não deixa →
+	* `UnsupportedError` com dica.
+	*/
+	checkNativeTools(tools, method = "complete") {
+		const natives = (tools ?? []).filter((t) => t instanceof require_version.NativeTool);
+		if (!natives.length) return;
+		const fail = (msg) => {
+			throw new require_errors.UnsupportedError(msg, { provider: this.name });
+		};
+		if (method === "parse" && !this.nativeToolsWithParse) fail(`${this.name} não aceita tools nativas junto com structured output (parse). Use complete({ tools }) e depois parse() sobre o texto.`);
+		const nomes = /* @__PURE__ */ new Set([this.name, ...this.nativeToolAliases]);
+		for (const t of natives) {
+			if (t.kind === "native") {
+				if (t.provider && nomes.has(t.provider)) {
+					if (this.nativeToolPassthrough) continue;
+					fail(`'${this.name}' não aceita payload nativo de tool (nativeTool): a API não tem tools server-side.`);
+				}
+				fail(`nativeTool('${t.provider}', ...) não se aplica ao provider '${this.name}' (o payload nativo só vale no provider indicado).`);
+			}
+			if (!this.nativeToolKinds.has(t.kind)) {
+				const suportadas = [...this.nativeToolKinds].sort().join(", ") || "nenhuma";
+				fail(`tool nativa '${t.kind}' não é suportada por '${this.name}' (suportadas aqui: ${suportadas}). Use nativeTool('${this.name}', <payload nativo>) se o SDK tiver algo equivalente.`);
+			}
+		}
+	}
+	/** Mensagem do `UnsupportedError` quando o provider não tem MCP. */
+	mcpUnsupportedMessage() {
+		return `O provider '${this.name}' não suporta MCP (mcpServers). Use Anthropic, OpenAI, Azure, Groq ou Gemini, ou rode o loop client-side com MCPClient + runAgent (funciona em qualquer provider).`;
+	}
+	/** Recusa `mcpServers` em provider sem suporte (antes de ir ao SDK). */
+	checkMcp(mcpServers) {
+		if (mcpServers?.length && !this.supportsMcp) throw new require_errors.UnsupportedError(this.mcpUnsupportedMessage(), { provider: this.name });
+	}
+	/** Cliente nativo, criado uma vez e reaproveitado. */
+	client() {
+		if (!this.clientPromise) this.clientPromise = this.buildClient().catch((e) => {
+			this.clientPromise = null;
+			throw e;
+		});
+		return this.clientPromise;
+	}
+	/** Para testes: injeta um cliente nativo falso. */
+	setClient(client) {
+		this.clientPromise = Promise.resolve(client);
+	}
+	resolveApiKey() {
+		if (this.apiKey) return this.apiKey;
+		return this.envKey ? require_env.getEnv(this.envKey) : void 0;
+	}
+	/**
+	* Streaming com a resposta completa no fim (texto, tools, usage). Padrão: chamada
+	* normal, entregue como um único pedaço de texto + `"done"`. Quem consegue montar
+	* a `Completion` a partir do stream sobrescreve.
+	*/
+	async *streamEvents(messages, options) {
+		const comp = await this.complete(messages, options);
+		if (comp.text) yield {
+			type: "text",
+			text: comp.text
+		};
+		yield {
+			type: "done",
+			text: "",
+			completion: comp
+		};
+	}
+	transcribe(_audio, _options) {
+		return Promise.reject(new require_errors.UnsupportedError(`O provider '${this.name}' não suporta transcrição de áudio.`, { provider: this.name }));
+	}
+	embed(_texts, _options) {
+		return Promise.reject(new require_errors.UnsupportedError(`O provider '${this.name}' não gera embeddings.`, { provider: this.name }));
+	}
+	ocr(_source, _options) {
+		return Promise.reject(new require_errors.UnsupportedError(`O provider '${this.name}' não faz OCR.`, { provider: this.name }));
+	}
+	/** Fecha o cliente nativo (se ele tiver `close()`). Idempotente. */
+	async close() {
+		const p = this.clientPromise;
+		this.clientPromise = null;
+		if (!p) return;
+		try {
+			const c = await p;
+			if (typeof c?.close === "function") await c.close();
+		} catch {}
+	}
+	/**
+	* Lança `TruncatedError` quando a resposta foi cortada por maxTokens. Chamado em
+	* `parse` ANTES de validar o JSON, para o erro ser claro ("aumente maxTokens").
+	*/
+	static checkTruncation(comp, provider) {
+		if (comp.finishReason === "length") {
+			const out = comp.usage?.outputTokens;
+			const onde = out ? ` em ${out} tokens de saída` : "";
+			throw new require_errors.TruncatedError(`resposta truncada${onde}: o modelo atingiu maxTokens antes de fechar o JSON. Aumente maxTokens (ex.: params: { maxTokens: 8192 }).`, { provider });
+		}
+	}
+	toString() {
+		return `<${this.constructor.name} model=${JSON.stringify(this.model)}>`;
+	}
+};
+Object.defineProperty(exports, "Provider", {
+	enumerable: true,
+	get: function() {
+		return Provider;
+	}
+});
+Object.defineProperty(exports, "applyProfile", {
+	enumerable: true,
+	get: function() {
+		return applyProfile;
+	}
+});
+Object.defineProperty(exports, "registerAlias", {
+	enumerable: true,
+	get: function() {
+		return registerAlias;
+	}
+});
+Object.defineProperty(exports, "registerProfile", {
+	enumerable: true,
+	get: function() {
+		return registerProfile;
+	}
+});