Feature/agentic folder tools + streaming resilience

all-model-chat/.github/workflows/quality-gates.yml

@@ -0,0 +1,29 @@
+name: Quality Gates
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  quality-gates:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run quality checks
+        run: npm run ci:check

all-model-chat/.gitignore

@@ -15,10 +15,33 @@ dist-ssr
 # Editor directories and files
 .vscode/*
 !.vscode/extensions.json
+.github/*
+!.github/workflows/
+!.github/workflows/**
 .idea
 .DS_Store
 *.suo
 *.ntvs*
 *.njsproj
 *.sln
 *.sw?
+
+# Generated files
+bundle-stats.html
+stats.html
+*.png
+*.pdf
+*.csv
+*.pkl
+__pycache__/
+
+# Temporary folders
+/chat-answer/
+/.agent/
+/chat/
+/setup/
+
+# Environment files
+.env
+.env.local
+.env.*.local

all-model-chat/apps/bff/.env.example

@@ -0,0 +1,28 @@
+# BFF runtime configuration
+BFF_HOST=127.0.0.1
+BFF_PORT=8787
+BFF_SERVICE_NAME=all-model-chat-bff
+NODE_ENV=development
+
+# Provider key configuration
+# Supports comma/newline separated key lists.
+GEMINI_API_KEYS=your-first-key,your-second-key
+
+# Optional single key fallback
+# GEMINI_API_KEY=your-single-key
+
+# Cooldown duration (milliseconds) after a key-level failure
+BFF_KEY_FAILURE_COOLDOWN_MS=30000
+
+# Provider endpoint mode
+# false => Gemini API
+# true => Vertex AI / Vertex Express
+BFF_PROVIDER_VERTEXAI=false
+
+# Optional provider endpoint override (full base URL without trailing slash)
+# Example for Vertex Express: https://aiplatform.googleapis.com
+# BFF_PROVIDER_BASE_URL=https://aiplatform.googleapis.com
+
+# Optional API version override
+# Example for Vertex Express stable: v1
+# BFF_PROVIDER_API_VERSION=v1

all-model-chat/apps/bff/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@all-model-chat/bff",
+  "private": true,
+  "version": "1.8.5",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "npm run build && npm run start",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test"
+  },
+  "dependencies": {
+    "@google/genai": "^1.2.0"
+  }
+}

all-model-chat/apps/bff/src/config/env.ts

@@ -0,0 +1,81 @@
+export interface BffConfig {
+  host: string;
+  port: number;
+  nodeEnv: string;
+  serviceName: string;
+  providerApiKeys: string[];
+  providerKeyFailureCooldownMs: number;
+  providerUseVertexAi: boolean;
+  providerBaseUrl?: string;
+  providerApiVersion?: string;
+}
+
+const parsePort = (rawPort: string | undefined, fallback: number): number => {
+  if (!rawPort) return fallback;
+
+  const parsed = Number(rawPort);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`Invalid BFF_PORT value: ${rawPort}`);
+  }
+
+  return parsed;
+};
+
+const parsePositiveInteger = (rawValue: string | undefined, fallback: number, fieldName: string): number => {
+  if (!rawValue) return fallback;
+
+  const parsed = Number(rawValue);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${fieldName} value: ${rawValue}`);
+  }
+
+  return parsed;
+};
+
+const parseBoolean = (rawValue: string | undefined, fallback: boolean, fieldName: string): boolean => {
+  if (!rawValue) return fallback;
+
+  const normalized = rawValue.trim().toLowerCase();
+  if (normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on') {
+    return true;
+  }
+  if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
+    return false;
+  }
+
+  throw new Error(`Invalid ${fieldName} value: ${rawValue}`);
+};
+
+const parseOptionalString = (rawValue: string | undefined): string | undefined => {
+  if (!rawValue) return undefined;
+
+  const trimmed = rawValue.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+};
+
+const parseProviderApiKeys = (rawList: string | undefined, rawSingle: string | undefined): string[] => {
+  const merged = [rawList || '', rawSingle || ''].join('\n');
+
+  return merged
+    .split(/[\n,]+/)
+    .map((key) => key.trim())
+    .filter((key) => key.length > 0);
+};
+
+export const loadBffConfig = (): BffConfig => {
+  return {
+    host: process.env.BFF_HOST || '127.0.0.1',
+    port: parsePort(process.env.BFF_PORT, 8787),
+    nodeEnv: process.env.NODE_ENV || 'development',
+    serviceName: process.env.BFF_SERVICE_NAME || 'all-model-chat-bff',
+    providerApiKeys: parseProviderApiKeys(process.env.GEMINI_API_KEYS, process.env.GEMINI_API_KEY),
+    providerKeyFailureCooldownMs: parsePositiveInteger(
+      process.env.BFF_KEY_FAILURE_COOLDOWN_MS,
+      30000,
+      'BFF_KEY_FAILURE_COOLDOWN_MS'
+    ),
+    providerUseVertexAi: parseBoolean(process.env.BFF_PROVIDER_VERTEXAI, false, 'BFF_PROVIDER_VERTEXAI'),
+    providerBaseUrl: parseOptionalString(process.env.BFF_PROVIDER_BASE_URL),
+    providerApiVersion: parseOptionalString(process.env.BFF_PROVIDER_API_VERSION),
+  };
+};

all-model-chat/apps/bff/src/index.ts

@@ -0,0 +1,119 @@
+import { createServer } from 'node:http';
+import { loadBffConfig } from './config/env.js';
+import { createHealthPayload } from './routes/health.js';
+import { ProviderKeyPool } from './providers/keyPool.js';
+import { GeminiProviderClient } from './providers/geminiClient.js';
+import { handleChatStreamRoute } from './routes/chatStream.js';
+import { handleFilesRoute } from './routes/files.js';
+import { handleGenerationRoute } from './routes/generation.js';
+
+const config = loadBffConfig();
+const keyPool = new ProviderKeyPool(config.providerApiKeys, {
+  failureCooldownMs: config.providerKeyFailureCooldownMs,
+});
+const geminiProviderClient = new GeminiProviderClient(keyPool, {
+  useVertexAi: config.providerUseVertexAi,
+  baseUrl: config.providerBaseUrl,
+  apiVersion: config.providerApiVersion,
+});
+
+const server = createServer((request, response) => {
+  if (!request.url) {
+    response.writeHead(400, { 'content-type': 'application/json; charset=utf-8' });
+    response.end(JSON.stringify({ error: 'Invalid request URL' }));
+    return;
+  }
+
+  const method = request.method || 'GET';
+  const path = request.url.split('?')[0];
+
+  if (method === 'GET' && path === '/health') {
+    const payload = createHealthPayload(
+      config,
+      geminiProviderClient.getKeyPoolSnapshot(),
+      geminiProviderClient.getProviderConfigSnapshot()
+    );
+    response.writeHead(200, { 'content-type': 'application/json; charset=utf-8' });
+    response.end(JSON.stringify(payload));
+    return;
+  }
+
+  if (path === '/api/chat/stream') {
+    if (method !== 'POST') {
+      response.writeHead(405, {
+        'content-type': 'application/json; charset=utf-8',
+        allow: 'POST',
+      });
+      response.end(JSON.stringify({ error: 'Method Not Allowed' }));
+      return;
+    }
+
+    handleChatStreamRoute(request, response, geminiProviderClient).catch((error) => {
+      if (response.writableEnded) {
+        return;
+      }
+
+      const message = error instanceof Error ? error.message : 'Unexpected stream proxy failure.';
+      response.writeHead(500, { 'content-type': 'application/json; charset=utf-8' });
+      response.end(
+        JSON.stringify({
+          error: {
+            code: 'internal_error',
+            message,
+            status: 500,
+          },
+        })
+      );
+    });
+    return;
+  }
+
+  if (path.startsWith('/api/files/')) {
+    handleFilesRoute(request, response, geminiProviderClient).catch((error) => {
+      if (response.writableEnded) return;
+      const message = error instanceof Error ? error.message : 'Unexpected files route failure.';
+      response.writeHead(500, { 'content-type': 'application/json; charset=utf-8' });
+      response.end(
+        JSON.stringify({
+          error: {
+            code: 'internal_error',
+            message,
+            status: 500,
+          },
+        })
+      );
+    });
+    return;
+  }
+
+  if (path.startsWith('/api/generation/')) {
+    handleGenerationRoute(request, response, geminiProviderClient).catch((error) => {
+      if (response.writableEnded) return;
+      const message = error instanceof Error ? error.message : 'Unexpected generation route failure.';
+      response.writeHead(500, { 'content-type': 'application/json; charset=utf-8' });
+      response.end(
+        JSON.stringify({
+          error: {
+            code: 'internal_error',
+            message,
+            status: 500,
+          },
+        })
+      );
+    });
+    return;
+  }
+
+  response.writeHead(404, { 'content-type': 'application/json; charset=utf-8' });
+  response.end(JSON.stringify({ error: 'Not Found' }));
+});
+
+server.listen(config.port, config.host, () => {
+  console.log(`[BFF] ${config.serviceName} listening on http://${config.host}:${config.port}`);
+  console.log(`[BFF] Provider key pool initialized with ${config.providerApiKeys.length} key(s).`);
+  console.log(
+    `[BFF] Provider mode: ${config.providerUseVertexAi ? 'vertexai' : 'gemini-api'} (baseUrl=${
+      config.providerBaseUrl || 'default'
+    }, apiVersion=${config.providerApiVersion || 'default'})`
+  );
+});