用 WebAssembly 编写插件

宿主                                   沙箱单元（guest 线性内存）
 │  malloc(in_len) ───────────────────▶ 分配 in_len 字节，返回偏移指针 in_ptr
 │  在 in_ptr 处写入入参 JSON 字节
 │  pre_hook(in_ptr, in_len) ─────────▶ read_string(in_ptr,in_len) 解析 JSON → 处置
 │                                       malloc(out_len) 分配出参缓冲 out_ptr
 │                                       write_string 写出参 JSON
 │  ◀───────── 返回打包 u64（高 32 位=out_ptr，低 32 位=out_len）
 │  按 out_ptr/out_len 读出参 JSON
 │  free(in_ptr, in_len) ─────────────▶ 释放入参缓冲
 │  free(out_ptr, out_len) ───────────▶ 释放出参缓冲

[package]
name = "lingqu-plugin-passthrough"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

// src/lib.rs —— 沙箱可加载单元（passthrough 直通骨架）
use serde::{Deserialize, Serialize};

// ===== memory：宿主与 guest 的内存握手 =====
mod memory {
    use std::alloc::{alloc, dealloc, Layout};

    // 宿主调用：在 guest 线性内存中分配 size 字节，返回偏移指针
    #[no_mangle]
    pub extern "C" fn malloc(size: u32) -> u32 {
        if size == 0 {
            return 0;
        }
        let layout = Layout::from_size_align(size as usize, 1).unwrap();
        unsafe { alloc(layout) as u32 }
    }

    // 宿主调用：释放 malloc 分配的缓冲（采用带 size 的形态）
    #[no_mangle]
    pub extern "C" fn free(ptr: u32, size: u32) {
        if ptr == 0 || size == 0 {
            return;
        }
        let layout = Layout::from_size_align(size as usize, 1).unwrap();
        unsafe { dealloc(ptr as *mut u8, layout) }
    }

    // guest 内部：把 ptr/len 处的字节读成入参 JSON 字符串
    pub fn read_string(ptr: u32, len: u32) -> String {
        let slice = unsafe { std::slice::from_raw_parts(ptr as *const u8, len as usize) };
        String::from_utf8_lossy(slice).into_owned()
    }

    // guest 内部：把出参 JSON 写入新缓冲，返回打包 u64（高 32 位=指针，低 32 位=长度）
    pub fn write_string(s: &str) -> u64 {
        let bytes = s.as_bytes();
        let len = bytes.len() as u32;
        let ptr = malloc(len);
        unsafe {
            std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr as *mut u8, len as usize);
        }
        ((ptr as u64) << 32) | (len as u64)
    }
}

// ===== 入参出参结构体（字段名对齐 Hook 契约）=====

#[derive(Deserialize)]
struct PreInput {
    phase: String,
    request_id: String,
    // 其余字段（api_key_id / request / routing / metadata / context）按需补充
}

#[derive(Serialize)]
struct PreResult {
    action: String, // continue | rewrite | short_circuit | reject
    #[serde(skip_serializing_if = "Option::is_none")]
    context: Option<serde_json::Value>,
}

#[derive(Deserialize)]
struct PostInput {
    phase: String,
    request_id: String,
    #[serde(default)]
    context: serde_json::Value,
}

#[derive(Serialize)]
struct PostResult {
    action: String, // pass | redact | block
}

// ===== 生命周期与 Hook 导出符号 =====

#[no_mangle]
pub extern "C" fn get_name() -> u64 {
    memory::write_string("出站直通插件")
}

#[no_mangle]
pub extern "C" fn init(config_ptr: u32, config_len: u32) -> i32 {
    let _config = memory::read_string(config_ptr, config_len);
    // 解析配置、建立一次性状态；成功返回 0
    0
}

#[no_mangle]
pub extern "C" fn pre_hook(input_ptr: u32, input_len: u32) -> u64 {
    let raw = memory::read_string(input_ptr, input_len);
    let _input: PreInput = match serde_json::from_str(&raw) {
        Ok(v) => v,
        Err(_) => return memory::write_string("{\"action\":\"continue\"}"),
    };
    let result = PreResult {
        action: "continue".to_string(),
        context: Some(serde_json::json!({ "marked_by": "出站直通插件" })),
    };
    memory::write_string(&serde_json::to_string(&result).unwrap())
}

#[no_mangle]
pub extern "C" fn post_hook(input_ptr: u32, input_len: u32) -> u64 {
    let raw = memory::read_string(input_ptr, input_len);
    let _input: PostInput = match serde_json::from_str(&raw) {
        Ok(v) => v,
        Err(_) => return memory::write_string("{\"action\":\"pass\"}"),
    };
    let result = PostResult { action: "pass".to_string() };
    memory::write_string(&serde_json::to_string(&result).unwrap())
}

#[no_mangle]
pub extern "C" fn cleanup() -> i32 {
    0
}

use serde::{Deserialize, Serialize};

// ===== 入参出参结构体 =====

#[derive(Deserialize)]
struct PreInput {
    request_id: String,
    request: RequestPayload,
    routing: Routing,
}

#[derive(Deserialize, Serialize, Clone)]
struct RequestPayload {
    model: String,
    messages: serde_json::Value, // 原样保留，不改用户语义
    #[serde(default)]
    stream: bool,
    // 治理面附加：结构化路由提示，仅供路由中间件消费
    #[serde(skip_serializing_if = "Option::is_none")]
    routing_hint: Option<RoutingHint>,
}

#[derive(Deserialize)]
struct Routing {
    complexity: String,       // 简单 | 复杂
    candidate_model: String,
}

#[derive(Deserialize, Serialize, Clone)]
struct RoutingHint {
    prefer_tier: String,
    reason: String,
}

#[derive(Serialize)]
struct PreResult {
    action: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    request: Option<RequestPayload>,
    context: serde_json::Value,
}

#[derive(Deserialize)]
struct PostInput {
    #[serde(default)]
    context: serde_json::Value,
}

// ===== 前置 Hook：复杂请求注入路由提示，决策写入 context =====

#[no_mangle]
pub extern "C" fn pre_hook(input_ptr: u32, input_len: u32) -> u64 {
    let raw = memory::read_string(input_ptr, input_len);
    let input: PreInput = match serde_json::from_str(&raw) {
        Ok(v) => v,
        Err(_) => return memory::write_string("{\"action\":\"continue\",\"context\":{}}"),
    };

    // 仅读 routing.complexity 做治理面研判
    if input.routing.complexity != "复杂" {
        let result = PreResult {
            action: "continue".to_string(),
            request: None,
            context: serde_json::json!({ "hint_applied": false }),
        };
        return memory::write_string(&serde_json::to_string(&result).unwrap());
    }

    // 复杂请求：注入结构化路由提示（不触碰 messages）
    let mut rewritten = input.request.clone();
    rewritten.routing_hint = Some(RoutingHint {
        prefer_tier: "high_capability".to_string(),
        reason: "complexity=复杂，建议路由至能力更强档".to_string(),
    });

    let result = PreResult {
        action: "rewrite".to_string(),
        request: Some(rewritten),
        context: serde_json::json!({
            "hint_applied": true,
            "candidate_model": input.routing.candidate_model,
        }),
    };
    memory::write_string(&serde_json::to_string(&result).unwrap())
}

// ===== 后置 Hook：读 context 做计量采样后放行 =====

#[no_mangle]
pub extern "C" fn post_hook(input_ptr: u32, input_len: u32) -> u64 {
    let raw = memory::read_string(input_ptr, input_len);
    let input: PostInput = serde_json::from_str(&raw)
        .unwrap_or(PostInput { context: serde_json::json!({}) });

    // 读取前置写入的 context 做一次计量采样（仅采集，不改内容）
    let hint_applied = input
        .context
        .get("hint_applied")
        .and_then(|v| v.as_bool())
        .unwrap_or(false);
    sample_metric("routing_hint_applied", hint_applied);

    memory::write_string("{\"action\":\"pass\"}")
}

// 计量采样：沙箱内无原生 IO，采样结果经平台计量底座归集
fn sample_metric(_key: &str, _value: bool) {
    // 仅采集决策标记，不接触响应内容（治理面）
}

tinygo build -o plugin.wasm -target=wasi

# 一次性：添加 wasm32 目标
rustup target add wasm32-unknown-unknown

# 构建沙箱单元
cargo build --release --target wasm32-unknown-unknown

# 产物（包名中的连字符在产物名里转为下划线）
#   target/wasm32-unknown-unknown/release/lingqu_plugin_passthrough.wasm

# 可选：压缩体积（标准 WASM 优化工具）
wasm-opt -Os target/wasm32-unknown-unknown/release/lingqu_plugin_passthrough.wasm \
  -o plugin.wasm

curl https://<平台入口地址>/api/v1/deployment \
  -H "Cookie: <控制台会话凭证>"

{
  "deploy_mode": "private",
  "deploy_status": "ready",
  "capabilities": {
    "dynamic_plugins": true
  }
}

curl https://<平台入口地址>/api/v1/pipeline/extensions \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Cookie: <控制台会话凭证>" \
  -d '{
    "name": "请求复杂度路由提示增强插件",
    "artifact_ref": "<.wasm 构建产物引用（加载位置/版本标识）>",
    "node_id": "<挂载的路由中间件节点>",
    "hook_type": "pre",
    "placement": "pre",
    "order": 20,
    "enabled": true,
    "config": {
      "<插件自定义配置项>": "<值>"
    },
    "fail_policy": "fail_open"
  }'