Update tiny-agent format to follow VSCode format (#1556)

Same PR as huggingface/huggingface_hub#3166 in
Python.

This PR introduces breaking changes but I think it's best to do it now.
Goal is to have the same format as [VSCode MCP
config](https://code.visualstudio.com/docs/copilot/chat/mcp-servers#_configuration-format)
e.g.

```json
{
  "model": "Qwen/Qwen2.5-72B-Instruct",
  "provider": "nebius",
  "inputs": [
    {
      "type": "promptString",
      "id": "hf-token",
      "description": "Token for Hugging Face API access",
      "password": true
    }
  ],
  "servers": [
    {
      "type": "http",
      "url": "https://huggingface.co/mcp",
      "headers": {
        "Authorization": "Bearer ${input:hf-token}"
      }
    }
  ]
}
```

breaking changes:
- no more `config` nested mapping => everything at root level
- `headers` at root level instead of inside options.requestInit
- updated the way values are pulled from ENV (based on input id)


Once this PR and
huggingface/huggingface_hub#3166 are approved,
we can merge + release them at the same time + update the config in
https://huggingface.co/datasets/tiny-agents/tiny-agents to follow the
new convention. For now, only
[wauplin/library-pr-reviewer](https://huggingface.co/datasets/tiny-agents/tiny-agents/tree/main/wauplin/library-pr-reviewer)
has been updated for testing.

```
pnpm run cli run wauplin/library-pr-reviewer
```

Author: Wauplin

packages/tiny-agents/src/cli.ts

@@ -4,6 +4,7 @@ import * as readline from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { z } from "zod";
 import { PROVIDERS_OR_POLICIES } from "@huggingface/inference";
+import type { ServerConfig } from "@huggingface/mcp-client";
 import { Agent } from "@huggingface/mcp-client";
 import { version as packageVersion } from "../package.json";
 import { InputConfigSchema, ServerConfigSchema } from "./lib/types";
@@ -107,15 +108,15 @@ async function main() {
 			// Check env variables that will use this input
 			const inputVars = new Set<string>();
 			for (const server of config.servers) {
-				if (server.type === "stdio" && server.config.env) {
-					for (const [key, value] of Object.entries(server.config.env)) {
+				if (server.type === "stdio" && server.env) {
+					for (const [key, value] of Object.entries(server.env)) {
 						if (value === envSpecialValue) {
 							inputVars.add(key);
 						}
 					}
 				}
-				if ((server.type === "http" || server.type === "sse") && server.config.options?.requestInit?.headers) {
-					for (const [key, value] of Object.entries(server.config.options.requestInit.headers)) {
+				if ((server.type === "http" || server.type === "sse") && server.headers) {
+					for (const [key, value] of Object.entries(server.headers)) {
 						if (value.includes(envSpecialValue)) {
 							inputVars.add(key);
 						}
@@ -132,54 +133,56 @@ async function main() {
 			}
 
 			// Prompt user for input
+			const envVariableKey = inputId.replaceAll("-", "_").toUpperCase();
 			stdout.write(ANSI.BLUE);
 			stdout.write(` • ${inputId}`);
 			stdout.write(ANSI.RESET);
-			stdout.write(`: ${description}. (default: load from ${Array.from(inputVars).join(", ")}) `);
+			stdout.write(`: ${description}. (default: load from ${envVariableKey}) `);
+			stdout.write("\n");
 
 			const userInput = (await rl.question("")).trim();
 
 			// Inject user input (or env variable) into servers' env
 			for (const server of config.servers) {
-				if (server.type === "stdio" && server.config.env) {
-					for (const [key, value] of Object.entries(server.config.env)) {
+				if (server.type === "stdio" && server.env) {
+					for (const [key, value] of Object.entries(server.env)) {
 						if (value === envSpecialValue) {
 							if (userInput) {
-								server.config.env[key] = userInput;
+								server.env[key] = userInput;
 							} else {
-								const valueFromEnv = process.env[key] || "";
-								server.config.env[key] = valueFromEnv;
+								const valueFromEnv = process.env[envVariableKey] || "";
+								server.env[key] = valueFromEnv;
 								if (valueFromEnv) {
 									stdout.write(ANSI.GREEN);
-									stdout.write(`Value successfully loaded from '${key}'`);
+									stdout.write(`Value successfully loaded from '${envVariableKey}'`);
 									stdout.write(ANSI.RESET);
 									stdout.write("\n");
 								} else {
 									stdout.write(ANSI.YELLOW);
-									stdout.write(`No value found for '${key}' in environment variables. Continuing.`);
+									stdout.write(`No value found for '${envVariableKey}' in environment variables. Continuing.`);
 									stdout.write(ANSI.RESET);
 									stdout.write("\n");
 								}
 							}
 						}
 					}
 				}
-				if ((server.type === "http" || server.type === "sse") && server.config.options?.requestInit?.headers) {
-					for (const [key, value] of Object.entries(server.config.options.requestInit.headers)) {
+				if ((server.type === "http" || server.type === "sse") && server.headers) {
+					for (const [key, value] of Object.entries(server.headers)) {
 						if (value.includes(envSpecialValue)) {
 							if (userInput) {
-								server.config.options.requestInit.headers[key] = value.replace(envSpecialValue, userInput);
+								server.headers[key] = value.replace(envSpecialValue, userInput);
 							} else {
-								const valueFromEnv = process.env[key] || "";
-								server.config.options.requestInit.headers[key] = value.replace(envSpecialValue, valueFromEnv);
+								const valueFromEnv = process.env[envVariableKey] || "";
+								server.headers[key] = value.replace(envSpecialValue, valueFromEnv);
 								if (valueFromEnv) {
 									stdout.write(ANSI.GREEN);
-									stdout.write(`Value successfully loaded from '${key}'`);
+									stdout.write(`Value successfully loaded from '${envVariableKey}'`);
 									stdout.write(ANSI.RESET);
 									stdout.write("\n");
 								} else {
 									stdout.write(ANSI.YELLOW);
-									stdout.write(`No value found for '${key}' in environment variables. Continuing.`);
+									stdout.write(`No value found for '${envVariableKey}' in environment variables. Continuing.`);
 									stdout.write(ANSI.RESET);
 									stdout.write("\n");
 								}
@@ -194,21 +197,47 @@ async function main() {
 		rl.close();
 	}
 
+	const formattedServers: ServerConfig[] = config.servers.map((server) => {
+		switch (server.type) {
+			case "stdio":
+				return {
+					type: "stdio",
+					config: {
+						command: server.command,
+						args: server.args ?? [],
+						env: server.env ?? {},
+						cwd: server.cwd ?? process.cwd(),
+					},
+				};
+			case "http":
+			case "sse":
+				return {
+					type: server.type,
+					config: {
+						url: server.url,
+						requestInit: {
+							headers: server.headers,
+						},
+					},
+				};
+		}
+	});
+
 	const agent = new Agent(
 		config.endpointUrl
 			? {
 					endpointUrl: config.endpointUrl,
 					model: config.model,
 					apiKey: config.apiKey ?? process.env.API_KEY ?? process.env.HF_TOKEN,
-					servers: config.servers,
+					servers: formattedServers,
 					prompt,
 			  }
 			: {
 					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 					provider: config.provider!,
 					model: config.model,
 					apiKey: config.apiKey ?? process.env.API_KEY ?? process.env.HF_TOKEN,
-					servers: config.servers,
+					servers: formattedServers,
 					prompt,
 			  }
 	);

packages/tiny-agents/src/lib/types.ts

@@ -8,53 +8,20 @@ export interface TinyAgentConfig {
 export const ServerConfigSchema = z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("stdio"),
-		config: z.object({
-			command: z.string(),
-			args: z.array(z.string()).optional(),
-			env: z.record(z.string()).optional(),
-			cwd: z.string().optional(),
-		}),
+		command: z.string(),
+		args: z.array(z.string()).optional(),
+		env: z.record(z.string()).optional(),
+		cwd: z.string().optional(),
 	}),
 	z.object({
 		type: z.literal("http"),
-		config: z.object({
-			url: z.union([z.string(), z.string().url()]),
-			options: z
-				.object({
-					/**
-					 * Customizes HTTP requests to the server.
-					 */
-					requestInit: z
-						.object({
-							headers: z.record(z.string()).optional(),
-						})
-						.optional(),
-					/**
-					 * Session ID for the connection. This is used to identify the session on the server.
-					 * When not provided and connecting to a server that supports session IDs, the server will generate a new session ID.
-					 */
-					sessionId: z.string().optional(),
-				})
-				.optional(),
-		}),
+		url: z.union([z.string(), z.string().url()]),
+		headers: z.record(z.string()).optional(),
 	}),
 	z.object({
 		type: z.literal("sse"),
-		config: z.object({
-			url: z.union([z.string(), z.string().url()]),
-			options: z
-				.object({
-					/**
-					 * Customizes HTTP requests to the server.
-					 */
-					requestInit: z
-						.object({
-							headers: z.record(z.string()).optional(),
-						})
-						.optional(),
-				})
-				.optional(),
-		}),
+		url: z.union([z.string(), z.string().url()]),
+		headers: z.record(z.string()).optional(),
 	}),
 ]);
 

packages/tiny-agents/test/ServerConfigSchema.spec.ts

@@ -5,10 +5,8 @@ describe("ServerConfigSchema", () => {
 	it("You can parse a server config", async () => {
 		const config = ServerConfigSchema.parse({
 			type: "stdio",
-			config: {
-				command: "npx",
-				args: ["@playwright/mcp@latest"],
-			},
+			command: "npx",
+			args: ["@playwright/mcp@latest"],
 		});
 		expect(config).toBeDefined();
 		expect(config.type).toBe("stdio");