@tencent-rtc/trtc-agent-skills 0.1.3 → 0.1.4

package/skills/trtc-ai-service/auto_adapters/integration_templates/generic-rest-api.md

@@ -0,0 +1,93 @@
+# Generic REST API Integration Guide (L3 Manual Fallback)
+
+> When the Agent cannot identify your tech stack, or it's not in the supported adapter list,
+> connect directly via the REST API exposed by conversation-core.
+
+## 1. Start the Skeleton
+
+```bash
+cd capabilities/conversation-core
+python -m src.server   # Default 0.0.0.0:3000
+```
+
+## 2. Endpoint List
+
+| Method | Path | Description |
+|:---|:---|:---|
+| GET  | `/api/v1/health`         | Real-time connectivity check for 3 keys |
+| POST | `/api/v1/get_config`     | Issue RoomId / UserSig |
+| POST | `/api/v1/agent/start`    | Start AI channel bot |
+| POST | `/api/v1/agent/stop`     | Stop AI channel bot |
+| POST | `/api/v1/agent/control`  | Text injection / interrupt |
+| GET  | `/api/v1/sessions`       | In-memory session list (debugging) |
+
+Capability extension endpoints:
+
+| Capability | Prefix |
+|:---|:---|
+| knowledge-base   | `/api/v1/kb/*` |
+| tool-calling     | `/api/v1/tools/*` |
+| human-handoff    | `/api/v1/handoff/*` |
+| session-summary  | `/api/v1/summary/*` |
+| digital-human    | `/api/v1/digital-human/*` |
+
+## 3. Call Examples
+
+### 3.1 Request Room Credentials
+
+```bash
+curl -X POST http://localhost:3000/api/v1/get_config \
+  -H "Content-Type: application/json" \
+  -d '{}'
+```
+
+Response:
+
+```json
+{
+  "code": 0,
+  "data": {
+    "session_id": "xxx",
+    "sdk_app_id": 1234567890,
+    "room_id": "987654321",
+    "user_id": "u_abc",
+    "user_sig": "...",
+    "agent_user_id": "ai_xyz",
+    "io_modality": { "voice_input": { ... } }
+  }
+}
+```
+
+### 3.2 Start AI Bot
+
+```bash
+curl -X POST http://localhost:3000/api/v1/agent/start \
+  -H "Content-Type: application/json" \
+  -d '{"session_id":"xxx","language":"zh"}'
+```
+
+### 3.3 Text Injection
+
+```bash
+curl -X POST http://localhost:3000/api/v1/agent/control \
+  -H "Content-Type: application/json" \
+  -d '{"session_id":"xxx","text":"Hello","interrupt":true}'
+```
+
+## 4. SDK Packages
+
+If you'd rather not call REST directly, use these SDKs:
+
+| Ecosystem | Package |
+|:---|:---|
+| npm   | `@trtc/voice-agent-sdk` |
+| maven | `com.tencent.trtc:voice-agent-sdk` |
+| pypi  | `trtc-voice-agent` |
+
+> SDK versions align with skeleton manifest; in Phase 2, REST is authoritative.
+
+## 5. Security Compliance
+
+- **HTTPS**: Enforce in production.
+- **SecretKey not sent to client**: The skeleton only sends `user_sig` (with TTL) to the client; never exposes `SDKSecretKey`.
+- **Log redaction**: The skeleton includes a built-in `RedactingFilter`; the reverse proxy layer should also suppress Authorization header logging.

package/skills/trtc-ai-service/auto_adapters/java-backend/README.md

@@ -0,0 +1,25 @@
+# java-backend Adapter
+
+Connect the conversation-core skeleton as a Filter into Spring Boot / Quarkus projects.
+
+| Framework | Template | Default Target |
+|:---|:---|:---|
+| Spring Boot | `springboot/VoiceAgentFilter.java.tpl` | `src/main/java/com/example/voiceagent/VoiceAgentFilter.java` |
+| Quarkus     | `quarkus/VoiceAgentFilter.java.tpl`    | Same as above |
+
+## Configuration
+
+`application.yml` / `application.properties`:
+
+```yaml
+skeleton:
+  base-url: ${SKELETON_BASE_URL}
+  api-prefix: ${API_PREFIX}
+  route-prefix: ${ROUTE_PREFIX}
+```
+
+## Notes
+
+- The template package `com.example.voiceagent` is replaced by the Agent during L1 rendering based on the user's actual project package name.
+- Default `connectTimeout=3s`, `request timeout=10s`; adjustable as needed.
+- Spring Boot registers `voiceAgentFilter` with order 10; should be placed before business Filters.

package/skills/trtc-ai-service/auto_adapters/java-backend/manifest.yaml

@@ -0,0 +1,30 @@
+name: "java-backend"
+version: "1.0.0"
+target_role: "backend"
+tech_stack: ["spring-boot", "quarkus"]
+description: "Java backend Filter: forward requests to skeleton process"
+
+templates:
+  spring-boot:
+    file: "springboot/VoiceAgentFilter.java.tpl"
+    target_path: "src/main/java/com/example/voiceagent/VoiceAgentFilter.java"
+    install_hint: |
+      Filter already includes @Component; Spring Boot auto-scans it.
+      To customize the path prefix, modify the PATH_PREFIX constant or inject via application.yml.
+    package_dependencies:
+      - "org.springframework.boot:spring-boot-starter-web"
+  quarkus:
+    file: "quarkus/VoiceAgentFilter.java.tpl"
+    target_path: "src/main/java/com/example/voiceagent/VoiceAgentFilter.java"
+    install_hint: |
+      Filter already includes @Provider; place the file in any package path scanned by Quarkus.
+    package_dependencies:
+      - "io.quarkus:quarkus-rest-client-reactive"
+
+defaults:
+  SKELETON_BASE_URL: "http://localhost:3000"
+  API_PREFIX: "/api/v1"
+  ROUTE_PREFIX: "/voice-agent"
+
+security:
+  https_required: true

package/skills/trtc-ai-service/auto_adapters/java-backend/quarkus/VoiceAgentFilter.java.tpl

@@ -0,0 +1,64 @@
+// VoiceAgentFilter.java  (Quarkus, JAX-RS ContainerRequestFilter)
+// Auto-generated by conversation-core/auto_adapters/java-backend
+package com.example.voiceagent;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.Entity;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.container.ContainerRequestFilter;
+import jakarta.ws.rs.container.PreMatching;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.ext.Provider;
+import org.eclipse.microprofile.config.inject.ConfigProperty;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+@Provider
+@PreMatching
+public class VoiceAgentFilter implements ContainerRequestFilter {
+
+    @ConfigProperty(name = "skeleton.base-url", defaultValue = "${SKELETON_BASE_URL}")
+    String skeletonBaseUrl;
+
+    @ConfigProperty(name = "skeleton.api-prefix", defaultValue = "${API_PREFIX}")
+    String apiPrefix;
+
+    @ConfigProperty(name = "skeleton.route-prefix", defaultValue = "${ROUTE_PREFIX}")
+    String routePrefix;
+
+    private final Client client = ClientBuilder.newClient();
+
+    @Override
+    public void filter(ContainerRequestContext ctx) throws IOException {
+        String path = ctx.getUriInfo().getPath();
+        if (!("/" + path).startsWith(routePrefix)) {
+            return;
+        }
+        String suffix = ("/" + path).substring(routePrefix.length());
+        String upstream = skeletonBaseUrl + apiPrefix + suffix;
+
+        try (InputStream in = ctx.getEntityStream()) {
+            byte[] body = in.readAllBytes();
+            Response.ResponseBuilder rb;
+            try {
+                Response resp;
+                if ("GET".equalsIgnoreCase(ctx.getMethod())) {
+                    resp = client.target(upstream).request().get();
+                } else {
+                    resp = client.target(upstream).request()
+                            .method(ctx.getMethod(),
+                                    Entity.entity(body, "application/json"));
+                }
+                rb = Response.status(resp.getStatus())
+                        .entity(resp.readEntity(byte[].class));
+            } catch (Exception e) {
+                rb = Response.status(502)
+                        .entity("{\"code\":\"bad_gateway\",\"message\":\""
+                                + e.getMessage().replace("\"", "'") + "\"}");
+            }
+            ctx.abortWith(rb.type("application/json").build());
+        }
+    }
+}

package/skills/trtc-ai-service/auto_adapters/java-backend/springboot/VoiceAgentFilter.java.tpl

@@ -0,0 +1,91 @@
+// VoiceAgentFilter.java  (Spring Boot)
+// Auto-generated by conversation-core/auto_adapters/java-backend
+// Reverse-proxy ${ROUTE_PREFIX}/* to skeleton ${SKELETON_BASE_URL}${API_PREFIX}/*
+package com.example.voiceagent;
+
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+
+@Component
+public class VoiceAgentFilter implements Filter {
+
+    @Value("${skeleton.base-url:${SKELETON_BASE_URL}}")
+    private String skeletonBaseUrl;
+
+    @Value("${skeleton.api-prefix:${API_PREFIX}}")
+    private String apiPrefix;
+
+    @Value("${skeleton.route-prefix:${ROUTE_PREFIX}}")
+    private String routePrefix;
+
+    private final HttpClient client = HttpClient.newBuilder()
+            .connectTimeout(Duration.ofSeconds(3))
+            .build();
+
+    @Override
+    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
+            throws IOException, ServletException {
+        HttpServletRequest httpReq = (HttpServletRequest) req;
+        HttpServletResponse httpRes = (HttpServletResponse) res;
+        String path = httpReq.getRequestURI();
+        if (!path.startsWith(routePrefix)) {
+            chain.doFilter(req, res);
+            return;
+        }
+        String suffix = path.substring(routePrefix.length());
+        String upstream = skeletonBaseUrl + apiPrefix + suffix;
+        try (InputStream in = httpReq.getInputStream()) {
+            byte[] body = in.readAllBytes();
+            HttpRequest.Builder builder = HttpRequest.newBuilder()
+                    .uri(URI.create(upstream))
+                    .timeout(Duration.ofSeconds(10))
+                    .header("Content-Type", "application/json");
+            switch (httpReq.getMethod()) {
+                case "GET":
+                case "HEAD":
+                    builder.GET();
+                    break;
+                case "DELETE":
+                    builder.DELETE();
+                    break;
+                default:
+                    builder.method(httpReq.getMethod(),
+                            HttpRequest.BodyPublishers.ofByteArray(body));
+            }
+            HttpResponse<byte[]> resp = client.send(builder.build(),
+                    HttpResponse.BodyHandlers.ofByteArray());
+            httpRes.setStatus(resp.statusCode());
+            resp.headers().firstValue("Content-Type").ifPresent(httpRes::setContentType);
+            httpRes.getOutputStream().write(resp.body());
+        } catch (Exception e) {
+            httpRes.setStatus(HttpServletResponse.SC_BAD_GATEWAY);
+            httpRes.getWriter().write(
+                    "{\"code\":\"bad_gateway\",\"message\":\""
+                            + e.getMessage().replace("\"", "'") + "\"}"
+            );
+        }
+    }
+
+    @Bean
+    public FilterRegistrationBean<VoiceAgentFilter> voiceAgentFilterRegistration() {
+        FilterRegistrationBean<VoiceAgentFilter> reg = new FilterRegistrationBean<>(this);
+        reg.addUrlPatterns(routePrefix + "/*");
+        reg.setName("voiceAgentFilter");
+        reg.setOrder(10);
+        return reg;
+    }
+}

package/skills/trtc-ai-service/auto_adapters/manifest.yaml

@@ -0,0 +1,43 @@
+# auto_adapters index manifest
+# For add-capability CLI / Agent to parse adapter-to-tech-stack mappings.
+
+version: "1.0.0"
+description: "Tech stack decoupling adapter component library, Phase 2 initial coverage of 4 adapter types / 12 tech stacks"
+
+# Rendering variable format ${VAR}, replaced by CLI before writing
+default_variables:
+  SKELETON_BASE_URL: "http://localhost:3000"
+  API_PREFIX: "/api/v1"
+  COMPONENT_NAME: "VoiceAgent"
+  ROUTE_PREFIX: "/voice-agent"
+
+adapters:
+  - name: "frontend-spa"
+    path: "frontend-spa"
+    tech_stack: ["react", "vue", "angular", "next"]
+    description: "Frontend SPA adapter, generates join-room component and connects to skeleton /api/v1/*"
+    target_role: "frontend"
+
+  - name: "node-backend"
+    path: "node-backend"
+    tech_stack: ["express", "koa", "fastify"]
+    description: "Node.js backend adapter, generates reverse proxy middleware"
+    target_role: "backend"
+
+  - name: "java-backend"
+    path: "java-backend"
+    tech_stack: ["spring-boot", "quarkus"]
+    description: "Java backend adapter, generates Filter / Quarkus Filter"
+    target_role: "backend"
+
+  - name: "python-backend"
+    path: "python-backend"
+    tech_stack: ["flask", "fastapi", "django"]
+    description: "Python backend adapter, generates decorators / sub-router mounting"
+    target_role: "backend"
+
+# General templates referenced by three-level degrader
+fallback_templates:
+  guided_frontend: "integration_templates/generic-frontend.md"
+  guided_backend: "integration_templates/generic-backend.md"
+  manual_rest_api: "integration_templates/generic-rest-api.md"

package/skills/trtc-ai-service/auto_adapters/node-backend/README.md

@@ -0,0 +1,25 @@
+# node-backend Adapter
+
+Connect the conversation-core skeleton as a reverse proxy into a Node.js backend,
+keeping the skeleton address hidden from the frontend and allowing the backend to inject auth / rate limiting / business policies before and after forwarding.
+
+| Framework | Template | Default Install Location |
+|:---|:---|:---|
+| Express | `express.js.tpl` | `routes/voice-agent.js` |
+| Koa     | `koa.js.tpl`     | `routes/voice-agent.js` |
+| Fastify | `fastify.js.tpl` | `routes/voice-agent.js` |
+
+## Configuration
+
+| Env Variable | Default | Description |
+|:---|:---|:---|
+| `SKELETON_BASE_URL` | `http://localhost:3000` | Skeleton process address |
+| `API_PREFIX`        | `/api/v1`             | Skeleton REST prefix |
+| `ROUTE_PREFIX`      | `/voice-agent`         | Self-mounting path |
+
+## Security
+
+- **SSRF Protection**: The template detects whether `SKELETON_BASE_URL` falls within private network ranges (`10/192.168/172.16-31/9/11/21/30/127`),
+  and will output a warning in production; internal network access requires explicit user confirmation.
+- **HTTPS**: Enforced in production deployment.
+- **Request Body Limit**: Default `64KB`, preventing malicious large payloads from overwhelming the skeleton ASR/LLM pipeline.

package/skills/trtc-ai-service/auto_adapters/node-backend/express.js.tpl

@@ -0,0 +1,40 @@
+// routes/voice-agent.js  (Express)
+// Auto-generated by conversation-core/auto_adapters/node-backend.
+// Reverse-proxy user requests to the skeleton process, avoiding direct frontend exposure of the skeleton address.
+const express = require('express');
+const fetch = (...args) => import('node-fetch').then(({ default: f }) => f(...args));
+
+const SKELETON_BASE_URL = process.env.SKELETON_BASE_URL || '${SKELETON_BASE_URL}';
+const API_PREFIX = process.env.API_PREFIX || '${API_PREFIX}';
+
+const router = express.Router();
+router.use(express.json({ limit: '64kb' }));
+
+// Security: prevent reverse proxy from pointing to private networks (aligned with global SSRF protection)
+function isPrivate(host) {
+  if (!host) return false;
+  const blocks = [/^10\./, /^192\.168\./, /^172\.(1[6-9]|2\d|3[0-1])\./, /^9\./, /^11\./, /^21\./, /^30\./, /^127\./];
+  return blocks.some((re) => re.test(host));
+}
+
+const target = new URL(SKELETON_BASE_URL);
+if (isPrivate(target.hostname) && process.env.NODE_ENV !== 'development') {
+  console.warn('[voice-agent] WARNING: SKELETON_BASE_URL points to a private network');
+}
+
+router.all('*', async (req, res) => {
+  const url = SKELETON_BASE_URL + API_PREFIX + req.path;
+  try {
+    const resp = await fetch(url, {
+      method: req.method,
+      headers: { 'Content-Type': 'application/json' },
+      body: ['GET', 'HEAD'].includes(req.method) ? undefined : JSON.stringify(req.body || {}),
+    });
+    const text = await resp.text();
+    res.status(resp.status).type(resp.headers.get('content-type') || 'application/json').send(text);
+  } catch (err) {
+    res.status(502).json({ code: 'bad_gateway', message: err.message });
+  }
+});
+
+module.exports = router;

package/skills/trtc-ai-service/auto_adapters/node-backend/fastify.js.tpl

@@ -0,0 +1,27 @@
+// routes/voice-agent.js  (Fastify plugin)
+// Auto-generated by conversation-core/auto_adapters/node-backend.
+const fetch = (...args) => import('node-fetch').then(({ default: f }) => f(...args));
+
+const SKELETON_BASE_URL = process.env.SKELETON_BASE_URL || '${SKELETON_BASE_URL}';
+const API_PREFIX = process.env.API_PREFIX || '${API_PREFIX}';
+
+module.exports = async function voiceAgent(fastify, _opts) {
+  fastify.all('/*', async (request, reply) => {
+    const url = SKELETON_BASE_URL + API_PREFIX + request.url.replace(/^\/voice-agent/, '');
+    try {
+      const body = ['GET', 'HEAD'].includes(request.method)
+        ? undefined
+        : JSON.stringify(request.body || {});
+      const resp = await fetch(url, {
+        method: request.method,
+        headers: { 'Content-Type': 'application/json' },
+        body,
+      });
+      reply.code(resp.status).type(resp.headers.get('content-type') || 'application/json');
+      return await resp.text();
+    } catch (err) {
+      reply.code(502);
+      return { code: 'bad_gateway', message: err.message };
+    }
+  });
+};

package/skills/trtc-ai-service/auto_adapters/node-backend/koa.js.tpl

@@ -0,0 +1,31 @@
+// routes/voice-agent.js  (Koa)
+// Auto-generated by conversation-core/auto_adapters/node-backend.
+const Router = require('@koa/router');
+const fetch = (...args) => import('node-fetch').then(({ default: f }) => f(...args));
+
+const SKELETON_BASE_URL = process.env.SKELETON_BASE_URL || '${SKELETON_BASE_URL}';
+const API_PREFIX = process.env.API_PREFIX || '${API_PREFIX}';
+const ROUTE_PREFIX = process.env.ROUTE_PREFIX || '${ROUTE_PREFIX}';
+
+const router = new Router({ prefix: ROUTE_PREFIX });
+
+router.all('(.*)', async (ctx) => {
+  const subPath = ctx.path.startsWith(ROUTE_PREFIX) ? ctx.path.slice(ROUTE_PREFIX.length) : ctx.path;
+  const url = SKELETON_BASE_URL + API_PREFIX + subPath;
+  try {
+    const body = ['GET', 'HEAD'].includes(ctx.method) ? undefined : JSON.stringify(ctx.request.body || {});
+    const resp = await fetch(url, {
+      method: ctx.method,
+      headers: { 'Content-Type': 'application/json' },
+      body,
+    });
+    ctx.status = resp.status;
+    ctx.set('Content-Type', resp.headers.get('content-type') || 'application/json');
+    ctx.body = await resp.text();
+  } catch (err) {
+    ctx.status = 502;
+    ctx.body = { code: 'bad_gateway', message: err.message };
+  }
+});
+
+module.exports = router;

package/skills/trtc-ai-service/auto_adapters/node-backend/manifest.yaml

@@ -0,0 +1,47 @@
+name: "node-backend"
+version: "1.0.0"
+target_role: "backend"
+tech_stack: ["express", "koa", "fastify"]
+description: "Node.js backend reverse proxy: transparently proxy ${ROUTE_PREFIX}/* to skeleton ${SKELETON_BASE_URL}${API_PREFIX}/*"
+
+templates:
+  express:
+    file: "express.js.tpl"
+    target_path: "routes/voice-agent.js"
+    install_hint: |
+      In Express app:
+        const voiceAgent = require('./routes/voice-agent');
+        app.use('${ROUTE_PREFIX}', voiceAgent);
+    package_dependencies:
+      - "express@^4.17.0"
+      - "node-fetch@^3.3.0"
+  koa:
+    file: "koa.js.tpl"
+    target_path: "routes/voice-agent.js"
+    install_hint: |
+      In Koa app:
+        const Router = require('@koa/router');
+        const proxy = require('./routes/voice-agent');
+        app.use(proxy.routes()).use(proxy.allowedMethods());
+    package_dependencies:
+      - "@koa/router@^12.0.0"
+      - "node-fetch@^3.3.0"
+  fastify:
+    file: "fastify.js.tpl"
+    target_path: "routes/voice-agent.js"
+    install_hint: |
+      In Fastify app:
+        const voiceAgent = require('./routes/voice-agent');
+        fastify.register(voiceAgent, { prefix: '${ROUTE_PREFIX}' });
+    package_dependencies:
+      - "fastify@^4.0.0"
+      - "node-fetch@^3.3.0"
+
+defaults:
+  SKELETON_BASE_URL: "http://localhost:3000"
+  API_PREFIX: "/api/v1"
+  ROUTE_PREFIX: "/voice-agent"
+
+security:
+  https_required: true
+  forbid_internal_ip: true   # Reverse proxy target defaults to rejecting private network ranges (10/192.168/172.16-31/9/11/21/30)

package/skills/trtc-ai-service/auto_adapters/python-backend/README.md

@@ -0,0 +1,22 @@
+# python-backend Adapter
+
+Connect the conversation-core skeleton as a reverse proxy into a Python backend.
+
+| Framework | Template | Default Target |
+|:---|:---|:---|
+| Flask    | `flask.py.tpl`    | `voice_agent_proxy.py` (Blueprint) |
+| FastAPI  | `fastapi.py.tpl`  | `voice_agent_proxy.py` (APIRouter) |
+| Django   | `django.py.tpl`   | `voice_agent_proxy/views.py` (function view) |
+
+## Configuration
+
+| Env Variable | Default | Description |
+|:---|:---|:---|
+| `SKELETON_BASE_URL` | `http://localhost:3000` | Skeleton address |
+| `API_PREFIX`        | `/api/v1`             | Skeleton prefix |
+| `ROUTE_PREFIX`      | `/voice-agent`         | Self-mounting path |
+
+## Notes
+
+- The Django template uses `@csrf_exempt`, suitable only for reverse proxy scenarios; for CSRF support, integrate DRF separately.
+- The FastAPI template is based on `httpx.AsyncClient`, aligning with the skeleton's async pipeline.

package/skills/trtc-ai-service/auto_adapters/python-backend/django.py.tpl

@@ -0,0 +1,32 @@
+# voice_agent_proxy/views.py  (Django function view)
+# Auto-generated by conversation-core/auto_adapters/python-backend
+import json
+import os
+
+import requests
+from django.http import HttpResponse, JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+
+SKELETON_BASE_URL = os.getenv("SKELETON_BASE_URL", "${SKELETON_BASE_URL}")
+API_PREFIX = os.getenv("API_PREFIX", "${API_PREFIX}")
+
+
+@csrf_exempt
+def proxy_view(request, rest: str = ""):
+    upstream = f"{SKELETON_BASE_URL}{API_PREFIX}/{rest}"
+    try:
+        kwargs = {"timeout": 10}
+        if request.method != "GET":
+            try:
+                kwargs["json"] = json.loads(request.body or b"{}")
+            except json.JSONDecodeError:
+                kwargs["json"] = {}
+        resp = requests.request(
+            request.method, upstream,
+            headers={"Content-Type": "application/json"},
+            **kwargs,
+        )
+        ctype = resp.headers.get("Content-Type", "application/json")
+        return HttpResponse(resp.content, status=resp.status_code, content_type=ctype)
+    except requests.RequestException as exc:
+        return JsonResponse({"code": "bad_gateway", "message": str(exc)}, status=502)

package/skills/trtc-ai-service/auto_adapters/python-backend/fastapi.py.tpl

@@ -0,0 +1,35 @@
+# voice_agent_proxy.py  (FastAPI sub-router)
+# Auto-generated by conversation-core/auto_adapters/python-backend
+import os
+from typing import Any, Dict, Optional
+
+import httpx
+from fastapi import APIRouter, HTTPException, Request
+
+SKELETON_BASE_URL = os.getenv("SKELETON_BASE_URL", "${SKELETON_BASE_URL}")
+API_PREFIX = os.getenv("API_PREFIX", "${API_PREFIX}")
+
+router = APIRouter()
+
+
+@router.api_route("/{subpath:path}", methods=["GET", "POST", "PUT", "DELETE"])
+async def proxy(subpath: str, request: Request) -> Any:
+    upstream = f"{SKELETON_BASE_URL}{API_PREFIX}/{subpath}"
+    body: Optional[Dict[str, Any]] = None
+    if request.method != "GET":
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+    async with httpx.AsyncClient(timeout=10) as client:
+        try:
+            resp = await client.request(
+                request.method, upstream,
+                headers={"Content-Type": "application/json"},
+                json=body if request.method != "GET" else None,
+            )
+        except httpx.HTTPError as exc:
+            raise HTTPException(status_code=502, detail={"code": "bad_gateway", "message": str(exc)})
+    if resp.headers.get("content-type", "").startswith("application/json"):
+        return resp.json()
+    return resp.text

package/skills/trtc-ai-service/auto_adapters/python-backend/flask.py.tpl

@@ -0,0 +1,31 @@
+# voice_agent_proxy.py  (Flask Blueprint)
+# Auto-generated by conversation-core/auto_adapters/python-backend
+import os
+from flask import Blueprint, request, Response
+import requests
+
+SKELETON_BASE_URL = os.getenv("SKELETON_BASE_URL", "${SKELETON_BASE_URL}")
+API_PREFIX = os.getenv("API_PREFIX", "${API_PREFIX}")
+
+bp = Blueprint("voice_agent_proxy", __name__)
+
+
+@bp.route("/<path:subpath>", methods=["GET", "POST", "PUT", "DELETE"])
+def proxy(subpath: str):
+    upstream = f"{SKELETON_BASE_URL}{API_PREFIX}/{subpath}"
+    try:
+        kwargs = {"timeout": 10}
+        if request.method != "GET":
+            kwargs["json"] = request.get_json(silent=True) or {}
+        resp = requests.request(
+            request.method, upstream,
+            headers={"Content-Type": "application/json"},
+            **kwargs,
+        )
+        return Response(
+            resp.content,
+            status=resp.status_code,
+            content_type=resp.headers.get("Content-Type", "application/json"),
+        )
+    except requests.RequestException as exc:
+        return {"code": "bad_gateway", "message": str(exc)}, 502