编写 Send

// agents/chat-app.ts
import { defineAgent } from "niceeval/adapter";

const BASE_URL = "http://localhost:8080";   // 要按 experiment 切换地址，改成工厂参数：见接入指南

export default defineAgent({
  name: "chat-app",
  async send(input, ctx) {
    ctx.progress({ message: "等待 Chat API" });
    const res = await fetch(`${BASE_URL}/v1/chat/completions`, {  // ← 前端本来就在用的接口
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        messages: [{ role: "user", content: input.text }],
        model: ctx.model,                                         // ← experiment.model 经 ctx.model 到这里；应用接口不支持选模型就删掉这行
      }),
      signal: ctx.signal,                                         // ← 运行器的超时与取消
    }).then((r) => r.json());

    return {
      status: "completed",
      events: [{ type: "message", role: "assistant", text: res.choices[0].message.content }],
    };
  },
});

if (!res.requestId) {
  ctx.diagnostic({
    code: "missing-request-id",
    level: "warning",
    message: "响应没有 request id，无法与服务端日志关联",
  });
}

// agents/chat-app.ts
import { defineAgent } from "niceeval/adapter";

const BASE_URL = "http://localhost:8080";

interface Msg { role: "user" | "assistant"; content: string | null }

export default defineAgent({
  name: "chat-app",
  async send(input, ctx) {
    const history = ctx.session.history<Msg>();  // ← 本会话线的历史槽；新会话线是空的
    const messages = [...history.get(), { role: "user" as const, content: input.text }];

    const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
      // ……method、headers、signal 同第一步，省略
      body: JSON.stringify({ messages, model: ctx.model }),        // ← 变化：发的是完整历史；model 同第一步转发
    }).then((r) => r.json());

    const reply = res.choices[0].message;
    history.commit([...messages, reply]);        // ← 写回；同一条线的下一轮 get() 自动带上

    return {
      status: "completed",
      events: [{ type: "message", role: "assistant", text: reply.content }],
    };
  },
});

// send 里：
//   请求体带上一轮的 id …… previous_response_id: ctx.session.id   ← 新会话线自然是 undefined
//   返回里抓到 id 就写回 …… ctx.session.capture(res.id)           ← 下一轮续接靠它

    // ……transport 与会话同第二步，省略
    return {
      status: "completed",
      events: [{ type: "message", role: "assistant", text: reply.content }],
      usage: {                                        // ← 变化：把接口回的用量如实报上
        inputTokens: res.usage.prompt_tokens,
        outputTokens: res.usage.completion_tokens,
      },
    };

type StreamEvent =
  | { type: "message"; role: "assistant" | "user"; text: string }
  | { type: "action.called"; callId: string; name: string; input: JsonValue; tool?: ToolName }
  | { type: "action.result"; callId: string; output?: JsonValue;
      status: "completed" | "failed" | "rejected" }
  | { type: "skill.loaded"; skill: string; callId?: string }
  | { type: "subagent.called"; callId: string; name: string; remoteUrl?: string }
  | { type: "subagent.completed"; callId: string; output?: JsonValue;
      status: "completed" | "failed" }
  | { type: "input.requested"; request: InputRequest }
  | { type: "thinking"; text: string }
  | { type: "compaction"; reason?: string }
  | { type: "error"; message: string };

    // ……transport 与会话同第二步，usage 同第三步，省略
    const reply = res.choices[0].message;

    const events: StreamEvent[] = [];
    for (const call of reply.tool_calls ?? []) {
      events.push({ type: "action.called", callId: call.id,
                    name: call.function.name, input: JSON.parse(call.function.arguments) });
    }
    if (reply.content) events.push({ type: "message", role: "assistant", text: reply.content });

    return { events, status: "completed", usage };

    // ……transport 与会话同第二步，省略
    return fromChatCompletion(res);            // ← 上面那段映射加第三步的 usage，官方版

// agents/my-app.ts
import { defineAgent, sseJsonFrames, fromPiAgentEvents, driveFrameStream } from "niceeval/adapter";
import type { AgentContext, PiAgentStream, SseFrameCursor } from "niceeval/adapter";
import type { Turn, TurnInput } from "niceeval";

const BASE_URL = "http://localhost:5299";               // 应用自己的端口，eval 不代管进程

interface Pending { cursor: SseFrameCursor<Frame>; stream: PiAgentStream; callId: string }

function readStream(cursor: SseFrameCursor<Frame>, ctx: AgentContext, stream: PiAgentStream): Promise<Turn> {
  return driveFrameStream(cursor, stream, ctx, (frame) => {
    if (frame.type === "session") {
      ctx.session.capture(frame.sessionId);             // ← 第二步：回传的 id 写回，下一轮续接
      return;
    }
    if (frame.type === "approval_request") {            // ← 本步：应用停下等审批，存下现场
      ctx.session.hold<Pending>({ cursor, stream, callId: frame.toolCallId });
      return { pause: { id: frame.toolCallId, action: frame.toolName,
                        options: [{ id: "approve" }, { id: "deny" }] } };
      // driveFrameStream 收到 pause：补一条 input.requested、status 置 "waiting"、停止读流
    }
    if (frame.type === "server_error") return { fail: frame.message };
  });
}

export default defineAgent({
  name: "my-app",
  async send(input: TurnInput, ctx: AgentContext): Promise<Turn> {
    const held = ctx.session.take<Pending>();
    if (held) {                                         // ← t.respond("approve")：普通 send，先交裁决
      const approved = input.responses?.[0]?.optionId === "approve";  // 多请求并停时按 requestId 对位
      if (!approved) held.stream.markRejected(held.callId);
      await fetch(`${BASE_URL}/api/chat/approve`, { method: "POST", signal: ctx.signal,
        body: JSON.stringify({ toolUseId: held.callId, approved }) });
      return readStream(held.cursor, ctx, held.stream); //    再接着读同一条流，不重发请求
    }

    const res = await fetch(`${BASE_URL}/api/chat`, {   // ← transport：唯一真正手写的一段
      method: "POST",
      body: JSON.stringify({
        message: input.text,                            // ← 第一步：发消息
        model: ctx.model,                               // ← 第一步：experiment.model 转发
        sessionId: ctx.session.id,                      // ← 第二步：第一次发自动不带，之后自动带
      }),
      signal: ctx.signal,
    });
    return readStream(sseJsonFrames<Frame>(res.body!), ctx, fromPiAgentEvents());  // ← 第四步：官方转换器零映射
  },
});

// niceeval.config.ts
import { defineConfig } from "niceeval";

export default defineConfig({
  telemetry: { port: 4318 },   // 接收器固定监听 http://localhost:4318/v1/traces
});

OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318/v1/traces node server.js

    const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
      // ……其余同第四步，省略
      headers: { "content-type": "application/json", ...ctx.telemetry?.headers },  // ← 只多这一行
    }).then((r) => r.json());

      // ……send 其余部分同前，省略
      body: JSON.stringify({
        messages,
        model: ctx.model,        // ← 第一步就转发的 experiment.model；这里一起列出
        flags: ctx.flags,      // ← experiment.flags 原样透传；没配时是 {}
      }),

// experiments/concise.ts
import { defineExperiment } from "niceeval";
import chatApp from "../agents/chat-app.ts";

export default defineExperiment({
  agent: chatApp,
  model: "gpt-5.4",                      // ← 经 ctx.model 到 send
  flags: { promptVariant: "concise" },  // ← 每轮经 ctx.flags 到 send
});