krisyotam/proxy

examples/plugin/jshandler/abi.go+110−6

@@ -92,6 +92,28 @@ type abiLifecycleRequest struct { · 91 unmodified lines
92	PluginDir string `json:"plugin_dir,omitempty"`	92	PluginDir string `json:"plugin_dir,omitempty"`
93	}	93	}
94		94
		95	type abiRequestInterceptRequest struct {
		96	pluginapi.RequestInterceptRequest
		97	HostCallbackID string `json:"host_callback_id,omitempty"`
		98	}
		99
		100	type abiResponseInterceptRequest struct {
		101	pluginapi.ResponseInterceptRequest
		102	HostCallbackID string `json:"host_callback_id,omitempty"`
		103	}
		104
		105	type abiStreamChunkInterceptRequest struct {
		106	pluginapi.StreamChunkInterceptRequest
		107	HostCallbackID string `json:"host_callback_id,omitempty"`
		108	}
		109
		110	type abiHostLogRequest struct {
		111	HostCallbackID string `json:"host_callback_id,omitempty"`
		112	Level string `json:"level,omitempty"`
		113	Message string `json:"message,omitempty"`
		114	Fields map[string]any `json:"fields,omitempty"`
		115	}
		116
95	type abiRegistration struct {	117	type abiRegistration struct {
96	SchemaVersion uint32 `json:"schema_version"`	118	SchemaVersion uint32 `json:"schema_version"`
97	Metadata pluginapi.Metadata `json:"metadata"`	119	Metadata pluginapi.Metadata `json:"metadata"`
@@ -192,25 +214,25 @@ func handleJSHandlerABIMethod(ctx context.Context, method string, request []byte · 94 unmodified lines
192	defer done()	214	defer done()
193	switch method {	215	switch method {
194	case pluginabi.MethodRequestInterceptBefore:	216	case pluginabi.MethodRequestInterceptBefore:
195	var req pluginapi.RequestInterceptRequest	217	var req abiRequestInterceptRequest
196	if errDecode := json.Unmarshal(request, &req); errDecode != nil {	218	if errDecode := json.Unmarshal(request, &req); errDecode != nil {
197	return nil, errDecode	219	return nil, errDecode
198	}	220	}
199	resp, errCall := p.InterceptRequest(ctx, req)	221	resp, errCall := p.interceptRequest(ctx, req.RequestInterceptRequest, req.HostCallbackID)
200	return abiOKEnvelopeWithError(resp, errCall)	222	return abiOKEnvelopeWithError(resp, errCall)
201	case pluginabi.MethodResponseInterceptAfter:	223	case pluginabi.MethodResponseInterceptAfter:
202	var req pluginapi.ResponseInterceptRequest	224	var req abiResponseInterceptRequest
203	if errDecode := json.Unmarshal(request, &req); errDecode != nil {	225	if errDecode := json.Unmarshal(request, &req); errDecode != nil {
204	return nil, errDecode	226	return nil, errDecode
205	}	227	}
206	resp, errCall := p.InterceptResponse(ctx, req)	228	resp, errCall := p.interceptResponse(ctx, req.ResponseInterceptRequest, req.HostCallbackID)
207	return abiOKEnvelopeWithError(resp, errCall)	229	return abiOKEnvelopeWithError(resp, errCall)
208	case pluginabi.MethodResponseInterceptStreamChunk:	230	case pluginabi.MethodResponseInterceptStreamChunk:
209	var req pluginapi.StreamChunkInterceptRequest	231	var req abiStreamChunkInterceptRequest
210	if errDecode := json.Unmarshal(request, &req); errDecode != nil {	232	if errDecode := json.Unmarshal(request, &req); errDecode != nil {
211	return nil, errDecode	233	return nil, errDecode
212	}	234	}
213	resp, errCall := p.InterceptStreamChunk(ctx, req)	235	resp, errCall := p.interceptStreamChunk(ctx, req.StreamChunkInterceptRequest, req.HostCallbackID)
214	return abiOKEnvelopeWithError(resp, errCall)	236	return abiOKEnvelopeWithError(resp, errCall)
215	default:	237	default:
216	return abiErrorEnvelope("unknown_method", "unknown method: "+method), nil	238	return abiErrorEnvelope("unknown_method", "unknown method: "+method), nil
@@ -289,3 +311,85 @@ func writeABIResponse(response *C.cliproxy_buffer, raw []byte) { · 72 unmodified lines
289	response.ptr = ptr	311	response.ptr = ptr
290	response.len = C.size_t(len(raw))	312	response.len = C.size_t(len(raw))
291	}	313	}
		314
		315	func newHostJSConsoleLogger(hostCallbackID string) jsConsoleLogger {
		316	return func(message string) error {
		317	if errLog := writeHostJSConsoleLog(hostCallbackID, message); errLog != nil {
		318	return defaultJSConsoleLogger(message)
		319	}
		320	return nil
		321	}
		322	}
		323
		324	func writeHostJSConsoleLog(hostCallbackID string, message string) error {
		325	raw, errMarshal := json.Marshal(abiHostLogRequest{
		326	HostCallbackID: hostCallbackID,
		327	Level: "info",
		328	Message: "JS console log: " + message,
		329	Fields: map[string]any{
		330	"plugin_id": pluginName,
		331	},
		332	})
		333	if errMarshal != nil {
		334	return errMarshal
		335	}
		336
		337	rawResp, errCall := callHost(pluginabi.MethodHostLog, raw)
		338	if errCall != nil {
		339	return errCall
		340	}
		341	if len(rawResp) == 0 {
		342	return nil
		343	}
		344	var resp abiEnvelope
		345	if errDecode := json.Unmarshal(rawResp, &resp); errDecode != nil {
		346	return fmt.Errorf("decode host log response: %w", errDecode)
		347	}
		348	if !resp.OK {
		349	if resp.Error != nil {
		350	return fmt.Errorf("host log failed: %s", resp.Error.Message)
		351	}
		352	return fmt.Errorf("host log failed")
		353	}
		354	return nil
		355	}
		356
		357	func callHost(method string, payload []byte) ([]byte, error) {
		358	jsHandlerABIState.RLock()
		359	defer jsHandlerABIState.RUnlock()
		360	if jsHandlerABIState.host == nil {
		361	return nil, fmt.Errorf("host callback is unavailable")
		362	}
		363
		364	cMethod := C.CString(method)
		365	defer C.free(unsafe.Pointer(cMethod))
		366
		367	var cPayload unsafe.Pointer
		368	if len(payload) > 0 {
		369	cPayload = C.CBytes(payload)
		370	if cPayload == nil {
		371	return nil, fmt.Errorf("allocate host callback payload")
		372	}
		373	defer C.free(cPayload)
		374	}
		375
		376	var response C.cliproxy_buffer
		377	rc := C.jshandler_call_host(
		378	jsHandlerABIState.host,
		379	cMethod,
		380	(*C.uint8_t)(cPayload),
		381	C.size_t(len(payload)),
		382	&response,
		383	)
		384	var out []byte
		385	if response.ptr != nil && response.len > 0 {
		386	out = C.GoBytes(response.ptr, C.int(response.len))
		387	}
		388	if response.ptr != nil {
		389	C.jshandler_free_host_buffer(jsHandlerABIState.host, response.ptr, response.len)
		390	}
		391	if rc != 0 {
		392	return nil, fmt.Errorf("host callback %s returned %d: %s", method, int(rc), string(out))
		393	}
		394	return out, nil
		395	}

examples/plugin/jshandler/engine.go+23−6

 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"time"
 )
 type jsEngine struct {
-	vm *goja.Runtime
+	vm            *goja.Runtime
+	consoleLogger jsConsoleLogger
 }
 const maxJSScriptBytes = 8 * 1024 * 1024
-func newJSEngine() *jsEngine {
+type jsConsoleLogger func(message string) error
+func newJSEngine(loggers ...jsConsoleLogger) *jsEngine {
+	consoleLogger := defaultJSConsoleLogger
+	if len(loggers) > 0 && loggers[0] != nil {
+		consoleLogger = loggers[0]
+	}
 	engine := &jsEngine{
-		vm: goja.New(),
+		vm:            goja.New(),
+		consoleLogger: consoleLogger,
 	}
 	engine.initConsole()
 	return engine
 }
+func defaultJSConsoleLogger(message string) error {
+	log.Info("JS console log: ", message)
+	return nil
+}
 func (engine *jsEngine) initConsole() {
 	console := engine.vm.NewObject()
 	consoleLogWrapper := func(call goja.FunctionCall) goja.Value {
-		args := make([]interface{}, len(call.Arguments))
+		args := make([]string, len(call.Arguments))
 		for i, arg := range call.Arguments {
-			args[i] = arg.Export()
+			args[i] = fmt.Sprint(arg.Export())
+		}
+		message := strings.Join(args, " ")
+		if errLog := engine.consoleLogger(message); errLog != nil {
+			defaultJSConsoleLogger(message)
 		}
-		log.Info("JS console log: ", fmt.Sprint(args...))
 		return goja.Undefined()
 	}
 	_ = console.Set("log", consoleLogWrapper)

examples/plugin/jshandler/engine_test.go+49−0

@@ -1,10 +1,59 @@
1	package main	1	package main
2		2
3	import (	3	import (
		4	"bytes"
		5	"strings"
4	"testing"	6	"testing"
5	"time"	7	"time"
		8
		9	log "github.com/sirupsen/logrus"
6	)	10	)
7		11
		12	func TestConsoleLogWritesToLogger(t *testing.T) {
		13	var out bytes.Buffer
		14	logger := log.StandardLogger()
		15	originalOut := logger.Out
		16	originalFormatter := logger.Formatter
		17	originalLevel := logger.Level
		18	log.SetOutput(&out)
		19	log.SetFormatter(&log.TextFormatter{
		20	DisableColors: true,
		21	DisableTimestamp: true,
		22	})
		23	log.SetLevel(log.InfoLevel)
		24	defer func() {
		25	log.SetOutput(originalOut)
		26	log.SetFormatter(originalFormatter)
		27	log.SetLevel(originalLevel)
		28	}()
		29
		30	engine := newJSEngine()
		31	_, errRun := engine.vm.RunString(`console.log("alpha", 42, true);`)
		32	if errRun != nil {
		33	t.Fatalf("RunString() error = %v", errRun)
		34	}
		35
		36	got := out.String()
		37	if !strings.Contains(got, "JS console log: alpha 42 true") {
		38	t.Fatalf("console.log output = %q, want logger output with JS message", got)
		39	}
		40	}
		41
		42	func TestConsoleLogUsesConfiguredLogger(t *testing.T) {
		43	var messages []string
		44	engine := newJSEngine(func(message string) error {
		45	messages = append(messages, message)
		46	return nil
		47	})
		48	_, errRun := engine.vm.RunString(`console.log("alpha", 42, true);`)
		49	if errRun != nil {
		50	t.Fatalf("RunString() error = %v", errRun)
		51	}
		52	if len(messages) != 1 \|\| messages[0] != "alpha 42 true" {
		53	t.Fatalf("console log messages = %#v, want formatted message", messages)
		54	}
		55	}
		56
8	func TestStopInterruptTimerClearsExpiredInterrupt(t *testing.T) {	57	func TestStopInterruptTimerClearsExpiredInterrupt(t *testing.T) {
9	engine := newJSEngine()	58	engine := newJSEngine()
10	timer, done := engine.startInterruptTimer(time.Nanosecond)	59	timer, done := engine.startInterruptTimer(time.Nanosecond)

examples/plugin/jshandler/interceptor.go+19−4

 }
 func (p *jsHandlerPlugin) InterceptRequest(ctx context.Context, req pluginapi.RequestInterceptRequest) (pluginapi.RequestInterceptResponse, error) {
+	return p.interceptRequest(ctx, req, "")
+}
+func (p *jsHandlerPlugin) interceptRequest(ctx context.Context, req pluginapi.RequestInterceptRequest, hostCallbackID string) (pluginapi.RequestInterceptResponse, error) {
 	resp := pluginapi.RequestInterceptResponse{}
 	scriptPaths := p.allScriptPaths()
 	if len(scriptPaths) == 0 {
 		if scriptPath == "" {
 			continue
 		}
-		processed, cleared, errJS := p.applyJSBeforeRequest(scriptPath, []byte(body), req.Model, req.SourceFormat, headers)
+		processed, cleared, errJS := p.applyJSBeforeRequest(scriptPath, []byte(body), req.Model, req.SourceFormat, headers, hostCallbackID)
 		if errJS != nil {
 			log.Warnf("failed to execute JS request interceptor [%s]: %v", scriptPath, errJS)
 			continue
 }
 func (p *jsHandlerPlugin) InterceptResponse(ctx context.Context, req pluginapi.ResponseInterceptRequest) (pluginapi.ResponseInterceptResponse, error) {
+	return p.interceptResponse(ctx, req, "")
+}
+func (p *jsHandlerPlugin) interceptResponse(ctx context.Context, req pluginapi.ResponseInterceptRequest, hostCallbackID string) (pluginapi.ResponseInterceptResponse, error) {
 	resp := pluginapi.ResponseInterceptResponse{}
 	scriptPaths := p.allScriptPaths()
 	if len(scriptPaths) == 0 {
 			scriptPath, req.Model, req.SourceFormat,
 			reqHeadersMap, req.RequestBody,
 			bodyStr, nil, respHeaders, false, nil,
+			hostCallbackID,
 		)
 		if errJS != nil {
 			log.Warnf("failed to execute JS response interceptor [%s]: %v", scriptPath, errJS)
 }
 func (p *jsHandlerPlugin) InterceptStreamChunk(ctx context.Context, req pluginapi.StreamChunkInterceptRequest) (pluginapi.StreamChunkInterceptResponse, error) {
+	return p.interceptStreamChunk(ctx, req, "")
+}
+func (p *jsHandlerPlugin) interceptStreamChunk(ctx context.Context, req pluginapi.StreamChunkInterceptRequest, hostCallbackID string) (pluginapi.StreamChunkInterceptResponse, error) {
 	resp := pluginapi.StreamChunkInterceptResponse{}
 	scriptPaths := p.allScriptPaths()
 	if len(scriptPaths) == 0 {
 			scriptPath, req.Model, req.SourceFormat,
 			reqHeadersMap, req.RequestBody,
 			"", chunkPtr, respHeaders, !isHeaderInit, historyStrings,
+			hostCallbackID,
 		)
 		if errJS != nil {
 			log.Warnf("failed to execute JS stream chunk interceptor [%s]: %v", scriptPath, errJS)
 	return resp, nil
 }
-func (p *jsHandlerPlugin) applyJSBeforeRequest(scriptPath string, payloadBytes []byte, model, protocol string, headers http.Header) ([]byte, []string, error) {
+func (p *jsHandlerPlugin) applyJSBeforeRequest(scriptPath string, payloadBytes []byte, model, protocol string, headers http.Header, hostCallbackID string) ([]byte, []string, error) {
 	program, err := getJSProgram(scriptPath)
 	if err != nil {
 		return nil, nil, err
 	}
-	engine := newJSEngine()
+	engine := newJSEngine(newHostJSConsoleLogger(hostCallbackID))
 	if errRun := engine.runProgram(program, p.cfg.Timeout); errRun != nil {
 		return nil, nil, errRun
 	}
 	reqHeadersMap map[string]any, reqBody []byte,
 	bodyStr string, chunkStr *string,
 	respHeaders http.Header, isStream bool, historyChunks []string,
+	hostCallbackID string,
 ) (string, *processedHeaders, bool, error) {
 	program, err := getJSProgram(scriptPath)
 	if err != nil {
 		return bodyStr, nil, false, err
 	}
-	engine := newJSEngine()
+	engine := newJSEngine(newHostJSConsoleLogger(hostCallbackID))
 	if errRun := engine.runProgram(program, p.cfg.Timeout); errRun != nil {
 		return bodyStr, nil, false, errRun
 	}

examples/plugin/jshandler/interceptor_test.go+3−0

 		"gpt-test",
 		"openai",
 		headers,
+		"",
 	)
 	if errApply != nil {
 		t.Fatalf("applyJSBeforeRequest() error = %v", errApply)
 		http.Header{},
 		true,
 		[]string{`data: {"choices":[{"delta":{"tool_calls":[{"index":0}]}}]}`},
+		"",
 	)
 	if errApply != nil {
 		t.Fatalf("applyJSAfterResponse() error = %v", errApply)
 		http.Header{},
 		false,
 		nil,
+		"",
 	)
 	if errApply != nil {
 		t.Fatalf("applyJSAfterResponse() error = %v", errApply)

internal/pluginhost/host_callbacks_test.go+44−0

@@ -6,13 +6,16 @@ import ( · 5 unmodified lines
6	"encoding/json"	6	"encoding/json"
7	"net/http"	7	"net/http"
8	"net/http/httptest"	8	"net/http/httptest"
		9	"strings"
9	"testing"	10	"testing"
10	"time"	11	"time"
11		12
12	"github.com/gin-gonic/gin"	13	"github.com/gin-gonic/gin"
13	"github.com/router-for-me/CLIProxyAPI/v7/internal/config"	14	"github.com/router-for-me/CLIProxyAPI/v7/internal/config"
		15	"github.com/router-for-me/CLIProxyAPI/v7/internal/logging"
14	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginabi"	16	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginabi"
15	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginapi"	17	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginapi"
		18	log "github.com/sirupsen/logrus"
16	)	19	)
17		20
18	func TestHostHTTPDoCallbackUsesHostHTTPClient(t *testing.T) {	21	func TestHostHTTPDoCallbackUsesHostHTTPClient(t *testing.T) {
@@ -213,3 +216,44 @@ func TestHostStreamCallbacksEmitAndClose(t *testing.T) { · 194 unmodified lines
213	t.Fatalf("stream remains open after close")	216	t.Fatalf("stream remains open after close")
214	}	217	}
215	}	218	}
		219
		220	func TestHostLogCallbackRestoresRegisteredRequestContext(t *testing.T) {
		221	host := New()
		222	ctx := logging.WithRequestID(context.Background(), "request-123")
		223	callbackID, closeCallback := host.openCallbackContext(ctx)
		224	defer closeCallback()
		225
		226	var out bytes.Buffer
		227	logger := log.StandardLogger()
		228	originalOut := logger.Out
		229	originalFormatter := logger.Formatter
		230	originalLevel := logger.Level
		231	log.SetOutput(&out)
		232	log.SetFormatter(&log.TextFormatter{
		233	DisableColors: true,
		234	DisableTimestamp: true,
		235	})
		236	log.SetLevel(log.InfoLevel)
		237	defer func() {
		238	log.SetOutput(originalOut)
		239	log.SetFormatter(originalFormatter)
		240	log.SetLevel(originalLevel)
		241	}()
		242
		243	rawReq, errMarshal := json.Marshal(rpcHostLogRequest{
		244	HostCallbackID: callbackID,
		245	Level: "info",
		246	Message: "plugin callback message",
		247	})
		248	if errMarshal != nil {
		249	t.Fatalf("marshal log request: %v", errMarshal)
		250	}
		251	if _, errCall := host.callFromPlugin(context.Background(), pluginabi.MethodHostLog, rawReq); errCall != nil {
		252	t.Fatalf("log callback error = %v", errCall)
		253	}
		254
		255	got := out.String()
		256	if !strings.Contains(got, "plugin callback message") \|\| !strings.Contains(got, "request_id=request-123") {
		257	t.Fatalf("log output = %q, want message and request_id field", got)
		258	}
		259	}

internal/pluginhost/host_test.go+69−0

@@ -7,6 +7,7 @@ import ( · 6 unmodified lines
7		7
8	"github.com/router-for-me/CLIProxyAPI/v7/internal/config"	8	"github.com/router-for-me/CLIProxyAPI/v7/internal/config"
9	"github.com/router-for-me/CLIProxyAPI/v7/internal/thinking"	9	"github.com/router-for-me/CLIProxyAPI/v7/internal/thinking"
		10	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginabi"
10	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginapi"	11	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginapi"
11	"github.com/tidwall/gjson"	12	"github.com/tidwall/gjson"
12	)	13	)
@@ -212,6 +213,47 @@ func TestInterceptorHelpersReturnErrorsWhenCallbackMissing(t *testing.T) { · 199 unmodified lines
212	}	213	}
213	}	214	}
214		215
		216	func TestRPCInterceptorsIncludeHostCallbackID(t *testing.T) {
		217	client := &capturePluginClient{}
		218	adapter := &rpcPluginAdapter{
		219	host: New(),
		220	client: client,
		221	}
		222
		223	if _, errReq := adapter.InterceptRequest(context.Background(), pluginapi.RequestInterceptRequest{Body: []byte("request")}); errReq != nil {
		224	t.Fatalf("InterceptRequest() error = %v", errReq)
		225	}
		226	var req rpcRequestInterceptRequest
		227	if errDecode := json.Unmarshal(client.requests[pluginabi.MethodRequestInterceptBefore], &req); errDecode != nil {
		228	t.Fatalf("decode request interceptor request: %v", errDecode)
		229	}
		230	if req.HostCallbackID == "" {
		231	t.Fatal("request interceptor host_callback_id is empty")
		232	}
		233
		234	if _, errResp := adapter.InterceptResponse(context.Background(), pluginapi.ResponseInterceptRequest{Body: []byte("response")}); errResp != nil {
		235	t.Fatalf("InterceptResponse() error = %v", errResp)
		236	}
		237	var resp rpcResponseInterceptRequest
		238	if errDecode := json.Unmarshal(client.requests[pluginabi.MethodResponseInterceptAfter], &resp); errDecode != nil {
		239	t.Fatalf("decode response interceptor request: %v", errDecode)
		240	}
		241	if resp.HostCallbackID == "" {
		242	t.Fatal("response interceptor host_callback_id is empty")
		243	}
		244
		245	if _, errChunk := adapter.InterceptStreamChunk(context.Background(), pluginapi.StreamChunkInterceptRequest{Body: []byte("chunk")}); errChunk != nil {
		246	t.Fatalf("InterceptStreamChunk() error = %v", errChunk)
		247	}
		248	var chunk rpcStreamChunkInterceptRequest
		249	if errDecode := json.Unmarshal(client.requests[pluginabi.MethodResponseInterceptStreamChunk], &chunk); errDecode != nil {
		250	t.Fatalf("decode stream chunk interceptor request: %v", errDecode)
		251	}
		252	if chunk.HostCallbackID == "" {
		253	t.Fatal("stream chunk interceptor host_callback_id is empty")
		254	}
		255	}
		256
215	func TestSanitizePluginRequestRemovesNonJSONMetadata(t *testing.T) {	257	func TestSanitizePluginRequestRemovesNonJSONMetadata(t *testing.T) {
216	req := pluginapi.RequestInterceptRequest{	258	req := pluginapi.RequestInterceptRequest{
217	Metadata: map[string]any{	259	Metadata: map[string]any{
@@ -257,6 +299,19 @@ func TestSanitizePluginRequestRemovesNonJSONMetadata(t *testing.T) { · 39 unmodified lines
257	if _, errMarshalExec := json.Marshal(sanitizePluginRequest(execReq)); errMarshalExec != nil {	299	if _, errMarshalExec := json.Marshal(sanitizePluginRequest(execReq)); errMarshalExec != nil {
258	t.Fatalf("Marshal(sanitized executor request) error = %v", errMarshalExec)	300	t.Fatalf("Marshal(sanitized executor request) error = %v", errMarshalExec)
259	}	301	}
		302
		303	wrappedReq := rpcRequestInterceptRequest{
		304	RequestInterceptRequest: pluginapi.RequestInterceptRequest{
		305	Metadata: map[string]any{
		306	"keep": "value",
		307	"callback": func(string) {},
		308	},
		309	},
		310	HostCallbackID: "callback-1",
		311	}
		312	if _, errMarshalWrapped := json.Marshal(sanitizePluginRequest(wrappedReq)); errMarshalWrapped != nil {
		313	t.Fatalf("Marshal(sanitized wrapped request interceptor) error = %v", errMarshalWrapped)
		314	}
260	}	315	}
261		316
262	func TestHostApplyConfig_ReconfigureCalledOnReload(t *testing.T) {	317	func TestHostApplyConfig_ReconfigureCalledOnReload(t *testing.T) {
@@ -407,3 +462,17 @@ func TestSortRecordsPriorityDescendingAndIDTieBreak(t *testing.T) { · 144 unmodified lines
407	}	462	}
408	}	463	}
409	}	464	}
		465
		466	type capturePluginClient struct {
		467	requests map[string][]byte
		468	}
		469
		470	func (c *capturePluginClient) Call(ctx context.Context, method string, request []byte) ([]byte, error) {
		471	if c.requests == nil {
		472	c.requests = make(map[string][]byte)
		473	}
		474	c.requests[method] = append([]byte(nil), request...)
		475	return marshalRPCResult(rpcEmptyResponse{})
		476	}
		477
		478	func (c *capturePluginClient) Shutdown() {}

internal/pluginhost/rpc_client.go+27−3

 	case pluginapi.StreamChunkInterceptRequest:
 		req.Metadata = sanitizePluginMetadata(req.Metadata)
 		return req
+	case rpcRequestInterceptRequest:
+		req.Metadata = sanitizePluginMetadata(req.Metadata)
+		return req
+	case rpcResponseInterceptRequest:
+		req.Metadata = sanitizePluginMetadata(req.Metadata)
+		return req
+	case rpcStreamChunkInterceptRequest:
+		req.Metadata = sanitizePluginMetadata(req.Metadata)
+		return req
 	case pluginapi.ExecutorHTTPRequest:
 		req.HTTPClient = nil
 		return req
 }
 func (a *rpcPluginAdapter) InterceptRequest(ctx context.Context, req pluginapi.RequestInterceptRequest) (pluginapi.RequestInterceptResponse, error) {
-	return callPlugin[pluginapi.RequestInterceptResponse](ctx, a.client, pluginabi.MethodRequestInterceptBefore, req)
+	callbackID, closeCallback := a.openHostCallbackContext(ctx)
+	defer closeCallback()
+	return callPlugin[pluginapi.RequestInterceptResponse](ctx, a.client, pluginabi.MethodRequestInterceptBefore, rpcRequestInterceptRequest{
+		RequestInterceptRequest: req,
+		HostCallbackID:          callbackID,
+	})
 }
 func (a *rpcPluginAdapter) TranslateResponse(ctx context.Context, req pluginapi.ResponseTransformRequest) (pluginapi.PayloadResponse, error) {
 }
 func (a *rpcPluginAdapter) InterceptResponse(ctx context.Context, req pluginapi.ResponseInterceptRequest) (pluginapi.ResponseInterceptResponse, error) {
-	return callPlugin[pluginapi.ResponseInterceptResponse](ctx, a.client, pluginabi.MethodResponseInterceptAfter, req)
+	callbackID, closeCallback := a.openHostCallbackContext(ctx)
+	defer closeCallback()
+	return callPlugin[pluginapi.ResponseInterceptResponse](ctx, a.client, pluginabi.MethodResponseInterceptAfter, rpcResponseInterceptRequest{
+		ResponseInterceptRequest: req,
+		HostCallbackID:           callbackID,
+	})
 }
 func (a *rpcPluginAdapter) InterceptStreamChunk(ctx context.Context, req pluginapi.StreamChunkInterceptRequest) (pluginapi.StreamChunkInterceptResponse, error) {
-	return callPlugin[pluginapi.StreamChunkInterceptResponse](ctx, a.client, pluginabi.MethodResponseInterceptStreamChunk, req)
+	callbackID, closeCallback := a.openHostCallbackContext(ctx)
+	defer closeCallback()
+	return callPlugin[pluginapi.StreamChunkInterceptResponse](ctx, a.client, pluginabi.MethodResponseInterceptStreamChunk, rpcStreamChunkInterceptRequest{
+		StreamChunkInterceptRequest: req,
+		HostCallbackID:              callbackID,
+	})
 }
 func (a rpcThinkingApplier) ApplyThinking(ctx context.Context, req pluginapi.ThinkingApplyRequest) (pluginapi.PayloadResponse, error) {

internal/pluginhost/rpc_schema.go+15−0

@@ -82,6 +82,21 @@ type rpcExecutorHTTPRequest struct { · 81 unmodified lines
82	HostCallbackID string `json:"host_callback_id,omitempty"`	82	HostCallbackID string `json:"host_callback_id,omitempty"`
83	}	83	}
84		84
		85	type rpcRequestInterceptRequest struct {
		86	pluginapi.RequestInterceptRequest
		87	HostCallbackID string `json:"host_callback_id,omitempty"`
		88	}
		89
		90	type rpcResponseInterceptRequest struct {
		91	pluginapi.ResponseInterceptRequest
		92	HostCallbackID string `json:"host_callback_id,omitempty"`
		93	}
		94
		95	type rpcStreamChunkInterceptRequest struct {
		96	pluginapi.StreamChunkInterceptRequest
		97	HostCallbackID string `json:"host_callback_id,omitempty"`
		98	}
		99
85	type rpcThinkingApplyRequest struct {	100	type rpcThinkingApplyRequest struct {
86	pluginapi.ThinkingApplyRequest	101	pluginapi.ThinkingApplyRequest
87	HostCallbackID string `json:"host_callback_id,omitempty"`	102	HostCallbackID string `json:"host_callback_id,omitempty"`