llm-api-gateway-cli 1.0.0

package/cli-anthropic.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * 模式二 · Anthropic 兼容接入
+ *
+ * 通过官方 `@anthropic-ai/sdk` 直连网关的 /v1/messages，验证网关可以作为
+ * api.anthropic.com 的 drop-in 替代 —— 客户端只需把 baseURL 指到网关、
+ * apiKey 换成网关发放的 sk- 密钥，其余代码完全不变。
+ *
+ * 用法示例：
+ *   node cli-anthropic.js "你好，用一句话介绍你自己"
+ *   node cli-anthropic.js -p "你好" --model qwen3:8b --system "你是中文助手"
+ *   echo "你好" | node cli-anthropic.js
+ *   node cli-anthropic.js -i                  # 多轮交互
+ *
+ * 另外：本脚本会额外发一个 W3C `baggage: session.id=<uuid>`（一次运行 = 一次对话），
+ * 好让网关后台的「任务树」把同一会话的多次请求聚成一条。这个头是**可选**的 ——
+ * 不发（或任何客户端不发）功能完全不受影响，网关会退回自己的推断口径。
+ *
+ * 密钥来源（优先级从高到低）：--key 参数 > 环境变量 SK / GATEWAY_KEY / ANTHROPIC_API_KEY > .env 文件
+ * 配置解析统一在 lib/config.js —— 四个入口共用一套优先级，不再各写一份。
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import readline from 'node:readline';
+import { randomUUID } from 'node:crypto';
+
+import { loadDotEnv, parseArgs, sessionBaggage, DEFAULT_BASE_URL } from './lib/common.js';
+import { resolveConfig, fail, KEY_HINT } from './lib/config.js';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+loadDotEnv(SCRIPT_DIR); // 先加载 .env，让 GATEWAY_MODEL 等环境变量参与默认值计算
+
+const DEFAULT_MODEL = process.env.GATEWAY_MODEL || 'qwen3:8b';
+const DEFAULT_MAX_TOKENS = 4096;
+
+const HELP = `用法：node cli-anthropic.js [选项] [提示词]
+
+选项：
+  -p, --prompt <文本>      单轮提问内容（省略则读位置参数 / 标准输入）
+  -s, --system <文本>      system 提示词
+  -m, --model <模型>       模型名（默认 ${DEFAULT_MODEL}）
+  -k, --key <sk-密钥>      网关发放的密钥（也可用环境变量 SK/GATEWAY_KEY/ANTHROPIC_API_KEY 或 .env）
+      --base-url <地址>    网关地址（默认 ${DEFAULT_BASE_URL}）
+      --max-tokens <值>    最大生成 token 数（Anthropic 必填，默认 ${DEFAULT_MAX_TOKENS}）
+      --temperature <值>   采样温度
+      --no-stream          关闭流式输出（默认开启）
+      --json               输出完整原始响应（非流式）
+  -i, --interactive        进入多轮交互（REPL）
+  -h, --help               显示帮助
+`;
+
+// 值型选项：会消费下一个参数作为值；布尔型选项：不消费后续参数
+const VALUE_FLAGS = {
+  '--prompt': 'prompt', '-p': 'prompt',
+  '--system': 'system', '-s': 'system',
+  '--model': 'model', '-m': 'model',
+  '--key': 'key', '-k': 'key',
+  '--base-url': 'base-url',
+  '--temperature': 'temperature',
+  '--max-tokens': 'max-tokens',
+};
+const BOOL_FLAGS = {
+  '--no-stream': 'no-stream',
+  '--json': 'json',
+  '--interactive': 'interactive', '-i': 'interactive',
+  '--help': 'help', '-h': 'help',
+};
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data.trim()));
+    process.stdin.on('error', () => resolve(''));
+  });
+}
+
+// ---------- 主流程 ----------
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2), VALUE_FLAGS, BOOL_FLAGS);
+
+  if (args.help) {
+    console.log(HELP);
+    return;
+  }
+
+  const { key, baseUrl, model, temperature, maxTokens } = resolveConfig(args, {
+    defaultModel: DEFAULT_MODEL,
+    defaultMaxTokens: DEFAULT_MAX_TOKENS,
+  });
+
+  if (!key) {
+    console.error(`[错误] ${KEY_HINT}`);
+    process.exit(1);
+  }
+
+  // 一次进程运行 = 一次对话。用 W3C baggage 告诉网关，好让它把同一会话的请求聚成一条。
+  const sessionId = randomUUID();
+  const baggage = sessionBaggage(sessionId);
+  if (baggage) process.stderr.write(`[gateway] 会话 ${sessionId}（W3C baggage: session.id）\n`);
+
+  const client = new Anthropic({
+    baseURL: baseUrl,
+    apiKey: key,
+    ...(baggage ? { defaultHeaders: { baggage } } : {}),
+  });
+  const stream = !args['no-stream'];
+
+  if (args.interactive) {
+    await repl(client, model, { stream, maxTokens, temperature });
+    return;
+  }
+
+  let prompt = args.prompt ?? '';
+  if (!prompt && args._.length) prompt = args._.join(' ');
+  if (!prompt) prompt = await readStdin();
+  if (!prompt) {
+    console.log(HELP);
+    return;
+  }
+
+  await chat(client, model, prompt, {
+    system: args.system,
+    stream,
+    maxTokens,
+    temperature,
+    json: args.json,
+    baseUrl,
+  });
+}
+
+/**
+ * @param {boolean} exitOnError 单轮/管道模式为 true；交互模式为 false（一次失败不结束会话）
+ */
+async function chat(client, model, prompt, { system, stream, maxTokens, temperature, json, baseUrl, exitOnError = true }) {
+  const req = {
+    model,
+    max_tokens: maxTokens,
+    messages: [{ role: 'user', content: prompt }],
+    stream,
+    temperature,
+  };
+  if (system) req.system = system;
+
+  process.stderr.write(`[gateway] model=${model} base=${baseUrl} stream=${stream}\n`);
+  try {
+    if (stream) {
+      let inputTokens = null;
+      let outputTokens = null;
+      for await (const event of await client.messages.create(req)) {
+        if (event.type === 'message_start') {
+          inputTokens = event.message?.usage?.input_tokens ?? null;
+        } else if (event.type === 'content_block_delta') {
+          const d = event.delta;
+          if (d?.type === 'text_delta') process.stdout.write(d.text);
+          else if (d?.type === 'input_json_delta') process.stdout.write(d.partial_json); // 工具调用参数
+        } else if (event.type === 'message_delta') {
+          outputTokens = event.usage?.output_tokens ?? null;
+        }
+      }
+      process.stdout.write('\n');
+      // 跨方言（Anthropic 入口 → OpenAI 上游）流式时网关不逐块回传 usage，仅在确有输出 token 时才展示
+      if (outputTokens !== null) {
+        process.stderr.write(`[usage] 输入 ${inputTokens ?? '?'} / 输出 ${outputTokens} tokens\n`);
+      }
+    } else {
+      const resp = await client.messages.create(req);
+      if (json) {
+        console.log(JSON.stringify(resp, null, 2));
+      } else {
+        const text = (resp.content || [])
+          .map((b) => (b.type === 'text' ? b.text : b.type === 'tool_use' ? `[工具调用 ${b.name}]` : ''))
+          .join('');
+        console.log(text);
+      }
+      const u = resp.usage;
+      if (u) process.stderr.write(`[usage] 输入 ${u.input_tokens ?? '?'} / 输出 ${u.output_tokens ?? '?'} tokens\n`);
+    }
+  } catch (e) {
+    fail(e, { exit: exitOnError });
+  }
+}
+
+async function repl(client, model, opts) {
+  console.error(`[gateway] 交互模式 model=${model}，输入文本提问，\`exit\` 退出`);
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const messages = [];
+  const ask = () => new Promise((resolve) => rl.question('你> ', resolve));
+  for (;;) {
+    let line;
+    try {
+      line = (await ask()).trim();
+    } catch {
+      break; // 输入流关闭（Ctrl+D）
+    }
+    if (!line) continue;
+    if (/^(exit|quit)$/i.test(line)) break;
+    messages.push({ role: 'user', content: line });
+
+    // 复用底层流式，逐字打印并把助手回复累积进上下文
+    process.stdout.write('助手> ');
+    const req = { model, max_tokens: opts.maxTokens, messages, stream: true, temperature: opts.temperature };
+    try {
+      let out = '';
+      let inputTokens = null;
+      let outputTokens = null;
+      for await (const event of await client.messages.create(req)) {
+        if (event.type === 'message_start') inputTokens = event.message?.usage?.input_tokens ?? null;
+        else if (event.type === 'content_block_delta') {
+          const d = event.delta;
+          if (d?.type === 'text_delta') {
+            process.stdout.write(d.text);
+            out += d.text;
+          }
+        } else if (event.type === 'message_delta') outputTokens = event.usage?.output_tokens ?? null;
+      }
+      process.stdout.write('\n');
+      if (outputTokens !== null) {
+        process.stderr.write(`[usage] 输入 ${inputTokens ?? '?'} / 输出 ${outputTokens} tokens\n`);
+      }
+      messages.push({ role: 'assistant', content: out });
+    } catch (e) {
+      // 交互模式：打印后继续，不要把整个会话带走
+      fail(e, { exit: false });
+      messages.pop();
+    }
+  }
+  rl.close();
+}
+
+main();

package/cli-claude-code.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+/**
+ * 模式三（推荐）· Claude Code CLI 接入
+ *
+ * 网关为每个 Agent 开发发放独立 sk- 密钥，Claude Code 通过
+ * ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN 直连网关即可把本地/DeepSeek 等
+ * 上游模型当后端使用。本脚本负责「设置环境变量 → 拉起 claude CLI」，
+ * 并把 `--` 之后的参数原样透传给 claude。
+ *
+ * 用法示例：
+ *   node cli-claude-code.js                        # 进入 Claude Code 交互界面
+ *   node cli-claude-code.js -- -p "用一句话介绍你自己"   # 透传 claude 参数（非交互）
+ *   node cli-claude-code.js --smoke                # 只做一次连通性自检后退出
+ *   node cli-claude-code.js --print-env            # 只打印要注入的环境变量
+ *   node cli-claude-code.js --config               # 打印 CC Switch 可用的 JSON 配置
+ *
+ * 密钥来源（优先级从高到低）：--key 参数 > 环境变量 SK / GATEWAY_KEY / ANTHROPIC_AUTH_TOKEN > .env 文件
+ * 密钥 / baseUrl / 模型的解析统一走 lib/config.js，与其余三个入口保持同一套优先级。
+ */
+
+import { spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+import { loadDotEnv, DEFAULT_BASE_URL, sessionBaggage } from './lib/common.js';
+import { resolveConfig, KEY_HINT } from './lib/config.js';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+loadDotEnv(SCRIPT_DIR); // 先加载 .env，让 GATEWAY_MODEL 等环境变量参与默认值计算
+
+const DEFAULT_MODEL = process.env.GATEWAY_MODEL || 'qwen3:8b';
+const DEFAULT_HAIKU = 'qwen3:8b-nothink';
+
+const HELP = `用法：node cli-claude-code.js [选项] [-- claude 参数...]
+
+选项（本脚本自身）：
+  -k, --key <sk-密钥>         网关发放的密钥（可用环境变量 SK/GATEWAY_KEY/ANTHROPIC_AUTH_TOKEN 或 .env）
+      --base-url <地址>       网关地址（默认 ${DEFAULT_BASE_URL}）
+  -m, --model <模型>          ANTHROPIC_MODEL，主模型（默认 ${DEFAULT_MODEL}）
+      --opus-model <模型>     ANTHROPIC_DEFAULT_OPUS_MODEL（默认同 --model）
+      --sonnet-model <模型>   ANTHROPIC_DEFAULT_SONNET_MODEL（默认同 --model）
+      --haiku-model <模型>    ANTHROPIC_DEFAULT_HAIKU_MODEL（默认 ${DEFAULT_HAIKU}）
+      --small-fast-model <模型> ANTHROPIC_SMALL_FAST_MODEL，后台快速模型（默认同 haiku）
+      --smoke                仅做一次 /v1/messages 连通性自检后退出，不拉起 claude
+      --print-env            仅打印要注入的环境变量，不拉起 claude
+      --config               打印 CC Switch / CC GUI 可直接粘贴的 JSON 配置
+  -h, --help                 显示帮助
+
+透传：\`--\` 之后的参数原样交给 claude，例如：
+  node cli-claude-code.js -- -p "你好" --model deepseek-v4-pro
+`;
+
+// ---------- 参数解析：本脚本自己的参数 vs 透传给 claude 的参数 ----------
+// 注意这里不能直接用 lib/common.js 的 parseArgs：本脚本要把「不认识的参数」
+// 原样透传给 claude，而通用解析器会把它们吃掉。
+
+const WITH_VALUE = {
+  '--key': 'key',
+  '--base-url': 'baseUrl',
+  '--model': 'model',
+  '--opus-model': 'opusModel',
+  '--sonnet-model': 'sonnetModel',
+  '--haiku-model': 'haikuModel',
+  '--small-fast-model': 'smallFastModel',
+  '-k': 'key',
+  '-m': 'model',
+};
+const FLAG = {
+  '--smoke': 'smoke',
+  '--print-env': 'printEnv',
+  '--config': 'config',
+  '--help': 'help',
+  '-h': 'help',
+};
+
+function parseArgs(argv) {
+  const opts = {};
+  const passthrough = [];
+  let afterDoubleDash = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (afterDoubleDash) {
+      passthrough.push(a);
+      continue;
+    }
+    if (a === '--') {
+      afterDoubleDash = true;
+      continue;
+    }
+    // --flag=value 形式（仅识别本脚本自己的参数）
+    const eq = a.indexOf('=');
+    if (eq !== -1 && a.startsWith('--')) {
+      const name = a.slice(0, eq);
+      const value = a.slice(eq + 1);
+      if (name in WITH_VALUE) {
+        opts[WITH_VALUE[name]] = value;
+        continue;
+      }
+    }
+    if (a in WITH_VALUE) {
+      const next = argv[i + 1];
+      opts[WITH_VALUE[a]] = next !== undefined ? next : true;
+      i++;
+      continue;
+    }
+    if (a in FLAG) {
+      opts[FLAG[a]] = true;
+      continue;
+    }
+    // 其余参数原样透传给 claude（含其值，交由 claude 自行解析）
+    passthrough.push(a);
+  }
+  return { opts, passthrough };
+}
+
+// ---------- 构建要注入的环境变量 ----------
+
+function buildEnv(opts, key, baseUrl, model) {
+  const haiku = opts.haikuModel || DEFAULT_HAIKU;
+  const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: baseUrl,
+    ANTHROPIC_AUTH_TOKEN: key,
+    ANTHROPIC_MODEL: model,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: opts.opusModel || model,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: opts.sonnetModel || model,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: haiku,
+    ANTHROPIC_SMALL_FAST_MODEL: opts.smallFastModel || haiku,
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1', // 关闭遥测/模型探测等非必要流量，避免网关收到陌生端点
+  };
+  // 任务树标记：告诉网关「这些调用属于同一趟会话」，否则网关只能靠指纹去猜。
+  // 真正的 HTTP 请求是 claude 自己发的，本脚本碰不到它的头，只能借 Claude Code
+  // 支持的自定义头环境变量注入（格式：每行一个 `名字: 值`，多行用 \n 分隔）。
+  // 一次进程启动 = 一趟会话：id 每次随机，所以两次启动是两个任务，不会互相污染。
+  // 想跨启动续同一趟会话，就自己设好 ANTHROPIC_CUSTOM_HEADERS（见下）。
+  const baggage = sessionBaggage(randomUUID());
+  if (baggage) {
+    const line = `baggage: ${baggage}`;
+    const cur = String(env.ANTHROPIC_CUSTOM_HEADERS || '').trim();
+    if (!cur) {
+      env.ANTHROPIC_CUSTOM_HEADERS = line;
+    } else if (!/baggage/i.test(cur)) {
+      env.ANTHROPIC_CUSTOM_HEADERS = `${cur}\n${line}`; // 追加，不覆盖用户其它自定义头
+    }
+    // 用户自己设过 baggage 就原样尊重：两条 baggage 会让接收方解析出怪东西
+  }
+  return env;
+}
+
+// ---------- 连通性自检：直接 POST /v1/messages ----------
+
+async function smoke(baseUrl, key, model) {
+  const url = `${baseUrl.replace(/\/+$/, '')}/v1/messages`;
+  // 用流式请求自检：Claude Code 实际走的就是 /v1/messages 的 SSE 流，最能反映真实可用性
+  // max_tokens 给足：本地 thinking 模型（如 qwen3:8b）会先把额度花在 reasoning 上，太小则看不到正文
+  const body = { model, max_tokens: 256, messages: [{ role: 'user', content: '你好，请用一句话回复' }], stream: true };
+  let res;
+  try {
+    res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-api-key': key,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify(body),
+    });
+  } catch (e) {
+    console.error(`[smoke] 连接异常: ${e?.message || e}`);
+    return false;
+  }
+  if (!res.ok) {
+    const text = await res.text();
+    console.error(`[smoke] 失败 HTTP ${res.status}: ${text.slice(0, 300)}`);
+    return false;
+  }
+
+  // 解析 SSE：收到 message_start 即证明网关已正确翻译并开始流式返回
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+  let started = false;
+  let reply = '';
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const parts = buf.split('\n\n');
+    buf = parts.pop();
+    for (const seg of parts) {
+      let eventType = null;
+      let data = null;
+      for (const line of seg.split('\n')) {
+        if (line.startsWith('event:')) eventType = line.slice(6).trim();
+        else if (line.startsWith('data:')) data = line.slice(5).trim();
+      }
+      if (!data) continue;
+      let obj = null;
+      try {
+        obj = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (eventType === 'message_start' || obj.type === 'message_start') {
+        started = true;
+      } else if (obj.type === 'content_block_delta' && obj.delta?.type === 'text_delta') {
+        reply += obj.delta.text;
+      }
+    }
+  }
+  if (!started) {
+    console.error('[smoke] 失败：未收到 message_start 事件');
+    return false;
+  }
+  console.error(`[smoke] 成功 model=${model} 回复="${reply.slice(0, 40)}"`);
+  return true;
+}
+
+// ---------- 拉起 claude ----------
+
+function runClaude(passthrough, env) {
+  // 先按裸可执行名直接 spawn（原生二进制 / 已加入 PATH 的情况）
+  const r = spawnSync('claude', passthrough, { env, stdio: 'inherit' });
+  if (!r.error) return r.status ?? 0;
+  // Windows 下 npm 安装的 claude 是 .cmd shim，直接 spawn 会报 ENOENT/EINVAL → 回退 shell 解析
+  if (r.error.code !== 'ENOENT' && r.error.code !== 'EINVAL') {
+    console.error(`[错误] 启动 claude 失败: ${r.error.message}`);
+    return 1;
+  }
+  const cmd = ['claude', ...passthrough].map((s) => (/[\s"&|<>]/.test(s) ? JSON.stringify(s) : s)).join(' ');
+  const r2 = spawnSync(cmd, { env, stdio: 'inherit', shell: true });
+  if (r2.error) {
+    console.error('[错误] 未找到 claude 命令：请先安装 Claude Code（npm install -g @anthropic-ai/claude-code）');
+    return 1;
+  }
+  return r2.status ?? 0;
+}
+
+// ---------- 主流程 ----------
+
+async function main() {
+  const { opts, passthrough } = parseArgs(process.argv.slice(2));
+
+  if (opts.help) {
+    console.log(HELP);
+    return;
+  }
+
+  // 本脚本的键名（baseUrl）与通用约定（base-url）不同，这里贴一下再交给 resolveConfig
+  const { key, baseUrl, model } = resolveConfig(
+    { key: opts.key, 'base-url': opts.baseUrl, model: opts.model },
+    { defaultModel: DEFAULT_MODEL },
+  );
+
+  if (!key) {
+    console.error(`[错误] ${KEY_HINT}`);
+    process.exit(1);
+  }
+
+  const env = buildEnv(opts, key, baseUrl, model);
+
+  if (opts.smoke) {
+    const ok = await smoke(baseUrl, key, model);
+    process.exit(ok ? 0 : 1);
+  }
+
+  if (opts.printEnv) {
+    const keys = [
+      'ANTHROPIC_BASE_URL',
+      'ANTHROPIC_AUTH_TOKEN',
+      'ANTHROPIC_MODEL',
+      'ANTHROPIC_DEFAULT_OPUS_MODEL',
+      'ANTHROPIC_DEFAULT_SONNET_MODEL',
+      'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+      'ANTHROPIC_SMALL_FAST_MODEL',
+      'ANTHROPIC_CUSTOM_HEADERS', // 任务树标记（W3C baggage: session.id）就走这个头
+      'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
+    ];
+    for (const k of keys) console.log(`${k}=${env[k]}`);
+    return;
+  }
+
+  if (opts.config) {
+    // 注意这里**不写** ANTHROPIC_CUSTOM_HEADERS：它是给「一次进程启动 = 一趟会话」用的
+    // 随机值，写进静态配置文件会让所有会话共用一个 id，反而把任务树并成一棵。
+    // 想用配置文件接入，请自己在那里写一行固定值（或改用本脚本启动）。
+    console.log(
+      JSON.stringify(
+        {
+          env: {
+            ANTHROPIC_AUTH_TOKEN: key,
+            ANTHROPIC_BASE_URL: baseUrl,
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+            ANTHROPIC_DEFAULT_OPUS_MODEL: env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+            ANTHROPIC_DEFAULT_SONNET_MODEL: env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+            ANTHROPIC_MODEL: env.ANTHROPIC_MODEL,
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+          },
+          theme: 'dark',
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  process.stderr.write(`[gateway] 启动 Claude Code：base=${baseUrl} model=${env.ANTHROPIC_MODEL}\n`);
+  // 把会话 id 显式打出来（与另外三个入口的提示一致），否则任务树里对不上是哪一次启动
+  const sid = /session\.id=([A-Za-z0-9._-]+)/.exec(String(env.ANTHROPIC_CUSTOM_HEADERS || ''));
+  if (sid) process.stderr.write(`[gateway] 会话 ${sid[1]}（W3C baggage: session.id）\n`);
+  const code = runClaude(passthrough, env);
+  process.exit(code);
+}
+
+main();