jangada-ai 0.1.0 → 1.0.0

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/{anthropic-BOBKTM1i.js → anthropic-BlqXqf9N.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-BFoano5Y.js";
+import { d as imageBase64, s as Completion, u as ToolCall } from "./context-C7qrmHGJ.js";
+import { c as NativeTool, i as splitTools } from "./version-CrHu1Pq_.js";
+import { n as applyProfile, t as Provider } from "./base-8WLtVj6O.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/{anthropic-D5xT9Yc4.cjs → anthropic-CYKRUh9e.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-C7tNbVHu.cjs");
+const require_context = require("./context-JTZvYRrC.cjs");
+const require_version = require("./version-Ch4xT-gQ.cjs");
+const require_base = require("./base-bplcDr6J.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_context.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_context.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_context.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/base-8WLtVj6O.js

@@ -0,0 +1,254 @@
+import { _ as UnsupportedError, g as TruncatedError } from "./errors-hp-4UePr.js";
+import { c as NativeTool } from "./version-CrHu1Pq_.js";
+import { n as getEnv } from "./env-BH4ulZ4_.js";
+// 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 NativeTool);
+		if (!natives.length) return;
+		const fail = (msg) => {
+			throw new 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 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 ? 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 UnsupportedError(`O provider '${this.name}' não suporta transcrição de áudio.`, { provider: this.name }));
+	}
+	embed(_texts, _options) {
+		return Promise.reject(new UnsupportedError(`O provider '${this.name}' não gera embeddings.`, { provider: this.name }));
+	}
+	ocr(_source, _options) {
+		return Promise.reject(new 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 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)}>`;
+	}
+};
+export { registerProfile as i, applyProfile as n, registerAlias as r, Provider as t };