chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,7 @@
|
||||
module github.com/router-for-me/CLIProxyAPI/v7/examples/plugin/host-model-callback/go
|
||||
|
||||
go 1.26.0
|
||||
|
||||
require github.com/router-for-me/CLIProxyAPI/v7 v7.0.0
|
||||
|
||||
replace github.com/router-for-me/CLIProxyAPI/v7 => ../../../..
|
||||
@@ -0,0 +1,731 @@
|
||||
package main
|
||||
|
||||
/*
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef struct {
|
||||
void* ptr;
|
||||
size_t len;
|
||||
} cliproxy_buffer;
|
||||
|
||||
typedef int (*cliproxy_host_call_fn)(void*, const char*, const uint8_t*, size_t, cliproxy_buffer*);
|
||||
typedef void (*cliproxy_host_free_fn)(void*, size_t);
|
||||
|
||||
typedef struct {
|
||||
uint32_t abi_version;
|
||||
void* host_ctx;
|
||||
cliproxy_host_call_fn call;
|
||||
cliproxy_host_free_fn free_buffer;
|
||||
} cliproxy_host_api;
|
||||
|
||||
typedef int (*cliproxy_plugin_call_fn)(char*, uint8_t*, size_t, cliproxy_buffer*);
|
||||
typedef void (*cliproxy_plugin_free_fn)(void*, size_t);
|
||||
typedef void (*cliproxy_plugin_shutdown_fn)(void);
|
||||
|
||||
typedef struct {
|
||||
uint32_t abi_version;
|
||||
cliproxy_plugin_call_fn call;
|
||||
cliproxy_plugin_free_fn free_buffer;
|
||||
cliproxy_plugin_shutdown_fn shutdown;
|
||||
} cliproxy_plugin_api;
|
||||
|
||||
extern int cliproxyPluginCall(char*, uint8_t*, size_t, cliproxy_buffer*);
|
||||
extern void cliproxyPluginFree(void*, size_t);
|
||||
extern void cliproxyPluginShutdown(void);
|
||||
|
||||
static const cliproxy_host_api* stored_host;
|
||||
|
||||
static void store_host_api(const cliproxy_host_api* host) {
|
||||
stored_host = host;
|
||||
}
|
||||
|
||||
static int call_host_api(const char* method, const uint8_t* request, size_t request_len, cliproxy_buffer* response) {
|
||||
if (stored_host == NULL || stored_host->call == NULL) {
|
||||
return 1;
|
||||
}
|
||||
return stored_host->call(stored_host->host_ctx, method, request, request_len, response);
|
||||
}
|
||||
|
||||
static void free_host_buffer(void* ptr, size_t len) {
|
||||
if (stored_host != NULL && stored_host->free_buffer != NULL && ptr != NULL) {
|
||||
stored_host->free_buffer(ptr, len);
|
||||
}
|
||||
}
|
||||
*/
|
||||
import "C"
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"html"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unsafe"
|
||||
|
||||
"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginabi"
|
||||
"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginapi"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultModel = "gpt-5.5"
|
||||
defaultPrompt = "Summarize host model callbacks in one short sentence."
|
||||
pluginName = "host-model-callback"
|
||||
resourcePath = "/status"
|
||||
resourceContentType = "text/html; charset=utf-8"
|
||||
)
|
||||
|
||||
type envelope struct {
|
||||
OK bool `json:"ok"`
|
||||
Result json.RawMessage `json:"result,omitempty"`
|
||||
Error *envelopeError `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
type envelopeError struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
type registration struct {
|
||||
SchemaVersion uint32 `json:"schema_version"`
|
||||
Metadata pluginapi.Metadata `json:"metadata"`
|
||||
Capabilities registrationCapabilities `json:"capabilities"`
|
||||
}
|
||||
|
||||
type registrationCapabilities struct {
|
||||
ManagementAPI bool `json:"management_api"`
|
||||
}
|
||||
|
||||
type managementRegistration struct {
|
||||
Resources []managementResource `json:"resources,omitempty"`
|
||||
}
|
||||
|
||||
type managementResource struct {
|
||||
Path string `json:"Path"`
|
||||
Menu string `json:"Menu"`
|
||||
Description string `json:"Description"`
|
||||
}
|
||||
|
||||
type managementRequest struct {
|
||||
Method string
|
||||
Path string
|
||||
Headers http.Header
|
||||
Query url.Values
|
||||
Body []byte
|
||||
HostCallbackID string `json:"host_callback_id,omitempty"`
|
||||
}
|
||||
|
||||
type managementResponse struct {
|
||||
StatusCode int `json:"StatusCode"`
|
||||
Headers http.Header `json:"Headers"`
|
||||
Body []byte `json:"Body"`
|
||||
}
|
||||
|
||||
type managementBodyOptions struct {
|
||||
Model string `json:"model"`
|
||||
Mode string `json:"mode"`
|
||||
EntryProtocol string `json:"entry_protocol"`
|
||||
ExitProtocol string `json:"exit_protocol"`
|
||||
Prompt string `json:"prompt"`
|
||||
Stream *bool `json:"stream"`
|
||||
Body json.RawMessage `json:"body"`
|
||||
Headers http.Header `json:"headers"`
|
||||
Query url.Values `json:"query"`
|
||||
Alt string `json:"alt"`
|
||||
ImplicitClose *bool `json:"implicit_close"`
|
||||
}
|
||||
|
||||
type hostModelExecutionRequest struct {
|
||||
pluginapi.HostModelExecutionRequest
|
||||
HostCallbackID string `json:"host_callback_id,omitempty"`
|
||||
}
|
||||
|
||||
type runOptions struct {
|
||||
Model string
|
||||
Mode string
|
||||
EntryProtocol string
|
||||
ExitProtocol string
|
||||
Prompt string
|
||||
Stream bool
|
||||
Body []byte
|
||||
Headers http.Header
|
||||
Query url.Values
|
||||
Alt string
|
||||
ImplicitClose bool
|
||||
HostCallbackID string
|
||||
}
|
||||
|
||||
type chatCompletionRequest struct {
|
||||
Model string `json:"model"`
|
||||
Stream bool `json:"stream"`
|
||||
Messages []chatMessage `json:"messages"`
|
||||
}
|
||||
|
||||
type chatMessage struct {
|
||||
Role string `json:"role"`
|
||||
Content string `json:"content"`
|
||||
}
|
||||
|
||||
type streamPageData struct {
|
||||
StatusCode int
|
||||
Headers http.Header
|
||||
StreamID string
|
||||
Chunks []string
|
||||
Error string
|
||||
CloseMode string
|
||||
CloseError string
|
||||
}
|
||||
|
||||
func main() {}
|
||||
|
||||
//export cliproxy_plugin_init
|
||||
func cliproxy_plugin_init(host *C.cliproxy_host_api, plugin *C.cliproxy_plugin_api) C.int {
|
||||
if plugin == nil {
|
||||
return 1
|
||||
}
|
||||
C.store_host_api(host)
|
||||
plugin.abi_version = C.uint32_t(pluginabi.ABIVersion)
|
||||
plugin.call = C.cliproxy_plugin_call_fn(C.cliproxyPluginCall)
|
||||
plugin.free_buffer = C.cliproxy_plugin_free_fn(C.cliproxyPluginFree)
|
||||
plugin.shutdown = C.cliproxy_plugin_shutdown_fn(C.cliproxyPluginShutdown)
|
||||
return 0
|
||||
}
|
||||
|
||||
//export cliproxyPluginCall
|
||||
func cliproxyPluginCall(method *C.char, request *C.uint8_t, requestLen C.size_t, response *C.cliproxy_buffer) C.int {
|
||||
if response != nil {
|
||||
response.ptr = nil
|
||||
response.len = 0
|
||||
}
|
||||
if method == nil {
|
||||
writeResponse(response, errorEnvelope("invalid_method", "method is required"))
|
||||
return 1
|
||||
}
|
||||
var requestBytes []byte
|
||||
if request != nil && requestLen > 0 {
|
||||
requestBytes = C.GoBytes(unsafe.Pointer(request), C.int(requestLen))
|
||||
}
|
||||
raw, errHandle := handleMethod(C.GoString(method), requestBytes)
|
||||
if errHandle != nil {
|
||||
writeResponse(response, errorEnvelope("plugin_error", errHandle.Error()))
|
||||
return 1
|
||||
}
|
||||
writeResponse(response, raw)
|
||||
return 0
|
||||
}
|
||||
|
||||
//export cliproxyPluginFree
|
||||
func cliproxyPluginFree(ptr unsafe.Pointer, len C.size_t) {
|
||||
if ptr != nil {
|
||||
C.free(ptr)
|
||||
}
|
||||
_ = len
|
||||
}
|
||||
|
||||
//export cliproxyPluginShutdown
|
||||
func cliproxyPluginShutdown() {}
|
||||
|
||||
func handleMethod(method string, request []byte) ([]byte, error) {
|
||||
switch method {
|
||||
case pluginabi.MethodPluginRegister, pluginabi.MethodPluginReconfigure:
|
||||
return okEnvelope(pluginRegistration())
|
||||
case pluginabi.MethodManagementRegister:
|
||||
return okEnvelope(managementRegistration{
|
||||
Resources: []managementResource{{
|
||||
Path: resourcePath,
|
||||
Menu: "Host Model Callback",
|
||||
Description: "Runs a model request through host.model callbacks and displays the result.",
|
||||
}},
|
||||
})
|
||||
case pluginabi.MethodManagementHandle:
|
||||
return handleManagement(request)
|
||||
default:
|
||||
return errorEnvelope("unknown_method", "unknown method: "+method), nil
|
||||
}
|
||||
}
|
||||
|
||||
func pluginRegistration() registration {
|
||||
return registration{
|
||||
SchemaVersion: pluginabi.SchemaVersion,
|
||||
Metadata: pluginapi.Metadata{
|
||||
Name: pluginName,
|
||||
Version: "0.1.0",
|
||||
Author: "router-for-me",
|
||||
GitHubRepository: "https://github.com/router-for-me/CLIProxyAPI",
|
||||
Logo: "https://raw.githubusercontent.com/router-for-me/CLIProxyAPI/main/docs/logo.png",
|
||||
ConfigFields: []pluginapi.ConfigField{},
|
||||
},
|
||||
Capabilities: registrationCapabilities{
|
||||
ManagementAPI: true,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func handleManagement(raw []byte) ([]byte, error) {
|
||||
var req managementRequest
|
||||
if len(raw) > 0 {
|
||||
if errUnmarshal := json.Unmarshal(raw, &req); errUnmarshal != nil {
|
||||
return nil, fmt.Errorf("decode management request: %w", errUnmarshal)
|
||||
}
|
||||
}
|
||||
opts, errOptions := optionsFromManagementRequest(req)
|
||||
if errOptions != nil {
|
||||
page := renderPage(opts, 0, nil, nil, nil, errOptions.Error(), "", "")
|
||||
return okEnvelope(htmlResponse(http.StatusBadRequest, page))
|
||||
}
|
||||
if opts.Stream {
|
||||
data := executeStream(opts)
|
||||
page := renderPage(opts, data.StatusCode, data.Headers, nil, data.Chunks, data.Error, data.CloseMode, data.CloseError)
|
||||
return okEnvelope(htmlResponse(http.StatusOK, page))
|
||||
}
|
||||
resp, errExecute := executeOnce(opts)
|
||||
if errExecute != nil {
|
||||
page := renderPage(opts, 0, nil, nil, nil, errExecute.Error(), "", "")
|
||||
return okEnvelope(htmlResponse(http.StatusOK, page))
|
||||
}
|
||||
page := renderPage(opts, resp.StatusCode, resp.Headers, resp.Body, nil, "", "", "")
|
||||
return okEnvelope(htmlResponse(http.StatusOK, page))
|
||||
}
|
||||
|
||||
func optionsFromManagementRequest(req managementRequest) (runOptions, error) {
|
||||
opts := runOptions{
|
||||
Model: defaultModel,
|
||||
Mode: "non-stream",
|
||||
EntryProtocol: "openai",
|
||||
ExitProtocol: "openai",
|
||||
Prompt: defaultPrompt,
|
||||
Headers: http.Header{},
|
||||
Query: url.Values{},
|
||||
}
|
||||
opts.HostCallbackID = strings.TrimSpace(req.HostCallbackID)
|
||||
if len(req.Body) > 0 {
|
||||
if errApplyBody := applyBodyOptions(&opts, req.Body); errApplyBody != nil {
|
||||
return opts, errApplyBody
|
||||
}
|
||||
}
|
||||
if errApplyQuery := applyQueryOptions(&opts, req.Query); errApplyQuery != nil {
|
||||
return opts, errApplyQuery
|
||||
}
|
||||
if opts.Stream {
|
||||
opts.Mode = "stream"
|
||||
} else {
|
||||
opts.Mode = "non-stream"
|
||||
}
|
||||
return opts, nil
|
||||
}
|
||||
|
||||
func applyBodyOptions(opts *runOptions, raw []byte) error {
|
||||
var bodyOpts managementBodyOptions
|
||||
if errUnmarshal := json.Unmarshal(raw, &bodyOpts); errUnmarshal != nil {
|
||||
return fmt.Errorf("decode JSON request body: %w", errUnmarshal)
|
||||
}
|
||||
if strings.TrimSpace(bodyOpts.Model) != "" {
|
||||
opts.Model = strings.TrimSpace(bodyOpts.Model)
|
||||
}
|
||||
if strings.TrimSpace(bodyOpts.Mode) != "" {
|
||||
applyMode(opts, bodyOpts.Mode)
|
||||
}
|
||||
if strings.TrimSpace(bodyOpts.EntryProtocol) != "" {
|
||||
opts.EntryProtocol = strings.TrimSpace(bodyOpts.EntryProtocol)
|
||||
}
|
||||
if strings.TrimSpace(bodyOpts.ExitProtocol) != "" {
|
||||
opts.ExitProtocol = strings.TrimSpace(bodyOpts.ExitProtocol)
|
||||
}
|
||||
if bodyOpts.Prompt != "" {
|
||||
opts.Prompt = bodyOpts.Prompt
|
||||
}
|
||||
if bodyOpts.Stream != nil {
|
||||
opts.Stream = *bodyOpts.Stream
|
||||
}
|
||||
if len(bodyOpts.Body) > 0 && string(bodyOpts.Body) != "null" {
|
||||
if !json.Valid(bodyOpts.Body) {
|
||||
return fmt.Errorf("body must be valid JSON")
|
||||
}
|
||||
opts.Body = append([]byte(nil), bodyOpts.Body...)
|
||||
}
|
||||
if bodyOpts.Headers != nil {
|
||||
opts.Headers = cloneHeader(bodyOpts.Headers)
|
||||
}
|
||||
if bodyOpts.Query != nil {
|
||||
opts.Query = cloneValues(bodyOpts.Query)
|
||||
}
|
||||
if bodyOpts.Alt != "" {
|
||||
opts.Alt = bodyOpts.Alt
|
||||
}
|
||||
if bodyOpts.ImplicitClose != nil {
|
||||
opts.ImplicitClose = *bodyOpts.ImplicitClose
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func applyQueryOptions(opts *runOptions, query url.Values) error {
|
||||
if query == nil {
|
||||
return nil
|
||||
}
|
||||
if raw := strings.TrimSpace(query.Get("model")); raw != "" {
|
||||
opts.Model = raw
|
||||
}
|
||||
if raw := strings.TrimSpace(query.Get("mode")); raw != "" {
|
||||
applyMode(opts, raw)
|
||||
}
|
||||
if raw := strings.TrimSpace(query.Get("entry_protocol")); raw != "" {
|
||||
opts.EntryProtocol = raw
|
||||
}
|
||||
if raw := strings.TrimSpace(query.Get("exit_protocol")); raw != "" {
|
||||
opts.ExitProtocol = raw
|
||||
}
|
||||
if raw := query.Get("prompt"); raw != "" {
|
||||
opts.Prompt = raw
|
||||
}
|
||||
if raw := strings.TrimSpace(query.Get("body")); raw != "" {
|
||||
body := []byte(raw)
|
||||
if !json.Valid(body) {
|
||||
return fmt.Errorf("query body must be valid JSON")
|
||||
}
|
||||
opts.Body = append([]byte(nil), body...)
|
||||
}
|
||||
if raw := strings.TrimSpace(query.Get("alt")); raw != "" {
|
||||
opts.Alt = raw
|
||||
}
|
||||
if errStream := applyBoolQuery(query, "stream", &opts.Stream); errStream != nil {
|
||||
return errStream
|
||||
}
|
||||
if errImplicitClose := applyBoolQuery(query, "implicit_close", &opts.ImplicitClose); errImplicitClose != nil {
|
||||
return errImplicitClose
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func applyMode(opts *runOptions, mode string) {
|
||||
normalized := strings.ToLower(strings.TrimSpace(mode))
|
||||
switch normalized {
|
||||
case "stream", "streaming":
|
||||
opts.Stream = true
|
||||
case "non-stream", "non_stream", "nonstream", "sync":
|
||||
opts.Stream = false
|
||||
}
|
||||
}
|
||||
|
||||
func applyBoolQuery(query url.Values, key string, target *bool) error {
|
||||
raw := strings.TrimSpace(query.Get(key))
|
||||
if raw == "" {
|
||||
return nil
|
||||
}
|
||||
parsed, errParse := strconv.ParseBool(raw)
|
||||
if errParse != nil {
|
||||
return fmt.Errorf("%s must be a boolean: %w", key, errParse)
|
||||
}
|
||||
*target = parsed
|
||||
return nil
|
||||
}
|
||||
|
||||
func executeOnce(opts runOptions) (pluginapi.HostModelExecutionResponse, error) {
|
||||
body, errBody := modelRequestBody(opts)
|
||||
if errBody != nil {
|
||||
return pluginapi.HostModelExecutionResponse{}, errBody
|
||||
}
|
||||
// Forward HostCallbackID so the host skips this plugin's interceptors on the
|
||||
// nested model execution. Host model callbacks do not recursively call the
|
||||
// originating plugin's interceptor chain.
|
||||
result, errCall := callHost(pluginabi.MethodHostModelExecute, hostModelExecutionRequest{
|
||||
HostModelExecutionRequest: pluginapi.HostModelExecutionRequest{
|
||||
EntryProtocol: opts.EntryProtocol,
|
||||
ExitProtocol: opts.ExitProtocol,
|
||||
Model: opts.Model,
|
||||
Stream: false,
|
||||
Body: body,
|
||||
Headers: cloneHeader(opts.Headers),
|
||||
Query: cloneValues(opts.Query),
|
||||
Alt: opts.Alt,
|
||||
},
|
||||
HostCallbackID: opts.HostCallbackID,
|
||||
})
|
||||
if errCall != nil {
|
||||
return pluginapi.HostModelExecutionResponse{}, errCall
|
||||
}
|
||||
var resp pluginapi.HostModelExecutionResponse
|
||||
if errUnmarshal := json.Unmarshal(result, &resp); errUnmarshal != nil {
|
||||
return pluginapi.HostModelExecutionResponse{}, fmt.Errorf("decode host.model.execute result: %w", errUnmarshal)
|
||||
}
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func executeStream(opts runOptions) (data streamPageData) {
|
||||
body, errBody := modelRequestBody(opts)
|
||||
if errBody != nil {
|
||||
data.Error = errBody.Error()
|
||||
return data
|
||||
}
|
||||
// Forward HostCallbackID so the host skips this plugin's interceptors on the
|
||||
// nested model execution. Host model callbacks do not recursively call the
|
||||
// originating plugin's interceptor chain.
|
||||
result, errCall := callHost(pluginabi.MethodHostModelExecuteStream, hostModelExecutionRequest{
|
||||
HostModelExecutionRequest: pluginapi.HostModelExecutionRequest{
|
||||
EntryProtocol: opts.EntryProtocol,
|
||||
ExitProtocol: opts.ExitProtocol,
|
||||
Model: opts.Model,
|
||||
Stream: true,
|
||||
Body: body,
|
||||
Headers: cloneHeader(opts.Headers),
|
||||
Query: cloneValues(opts.Query),
|
||||
Alt: opts.Alt,
|
||||
},
|
||||
HostCallbackID: opts.HostCallbackID,
|
||||
})
|
||||
if errCall != nil {
|
||||
data.Error = errCall.Error()
|
||||
return data
|
||||
}
|
||||
var resp pluginapi.HostModelStreamResponse
|
||||
if errUnmarshal := json.Unmarshal(result, &resp); errUnmarshal != nil {
|
||||
data.Error = fmt.Sprintf("decode host.model.execute_stream result: %v", errUnmarshal)
|
||||
return data
|
||||
}
|
||||
data.StatusCode = resp.StatusCode
|
||||
data.Headers = cloneHeader(resp.Headers)
|
||||
data.StreamID = resp.StreamID
|
||||
if resp.StreamID == "" {
|
||||
data.Error = "host.model.execute_stream returned an empty stream_id"
|
||||
return data
|
||||
}
|
||||
if opts.ImplicitClose {
|
||||
// When implicit_close=true, the host closes this stream when the management.handle RPC callback scope returns.
|
||||
data.CloseMode = "implicit close at management.handle return"
|
||||
} else {
|
||||
data.CloseMode = "explicit close through host.model.stream_close"
|
||||
defer func() {
|
||||
if errClose := closeHostModelStream(resp.StreamID); errClose != nil {
|
||||
data.CloseError = errClose.Error()
|
||||
}
|
||||
}()
|
||||
}
|
||||
for {
|
||||
chunk, errRead := readHostModelStream(resp.StreamID)
|
||||
if errRead != nil {
|
||||
data.Error = errRead.Error()
|
||||
return data
|
||||
}
|
||||
if len(chunk.Payload) > 0 {
|
||||
data.Chunks = append(data.Chunks, string(chunk.Payload))
|
||||
}
|
||||
if chunk.Error != "" {
|
||||
data.Error = chunk.Error
|
||||
return data
|
||||
}
|
||||
if chunk.Done {
|
||||
return data
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func readHostModelStream(streamID string) (pluginapi.HostModelStreamReadResponse, error) {
|
||||
result, errCall := callHost(pluginabi.MethodHostModelStreamRead, pluginapi.HostModelStreamReadRequest{StreamID: streamID})
|
||||
if errCall != nil {
|
||||
return pluginapi.HostModelStreamReadResponse{}, errCall
|
||||
}
|
||||
var resp pluginapi.HostModelStreamReadResponse
|
||||
if errUnmarshal := json.Unmarshal(result, &resp); errUnmarshal != nil {
|
||||
return pluginapi.HostModelStreamReadResponse{}, fmt.Errorf("decode host.model.stream_read result: %w", errUnmarshal)
|
||||
}
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func closeHostModelStream(streamID string) error {
|
||||
_, errCall := callHost(pluginabi.MethodHostModelStreamClose, pluginapi.HostModelStreamCloseRequest{StreamID: streamID})
|
||||
return errCall
|
||||
}
|
||||
|
||||
func modelRequestBody(opts runOptions) ([]byte, error) {
|
||||
if len(opts.Body) > 0 {
|
||||
return append([]byte(nil), opts.Body...), nil
|
||||
}
|
||||
raw, errMarshal := json.Marshal(chatCompletionRequest{
|
||||
Model: opts.Model,
|
||||
Stream: opts.Stream,
|
||||
Messages: []chatMessage{{
|
||||
Role: "user",
|
||||
Content: opts.Prompt,
|
||||
}},
|
||||
})
|
||||
if errMarshal != nil {
|
||||
return nil, fmt.Errorf("marshal OpenAI-compatible request body: %w", errMarshal)
|
||||
}
|
||||
return raw, nil
|
||||
}
|
||||
|
||||
func callHost(method string, payload any) (json.RawMessage, error) {
|
||||
rawPayload, errMarshal := json.Marshal(payload)
|
||||
if errMarshal != nil {
|
||||
return nil, fmt.Errorf("marshal host callback payload %s: %w", method, errMarshal)
|
||||
}
|
||||
cMethod := C.CString(method)
|
||||
defer C.free(unsafe.Pointer(cMethod))
|
||||
|
||||
var response C.cliproxy_buffer
|
||||
var requestPtr *C.uint8_t
|
||||
if len(rawPayload) > 0 {
|
||||
cPayload := C.CBytes(rawPayload)
|
||||
if cPayload == nil {
|
||||
return nil, fmt.Errorf("allocate host callback payload %s", method)
|
||||
}
|
||||
defer C.free(cPayload)
|
||||
requestPtr = (*C.uint8_t)(cPayload)
|
||||
}
|
||||
callCode := C.call_host_api(cMethod, requestPtr, C.size_t(len(rawPayload)), &response)
|
||||
var rawResponse []byte
|
||||
if response.ptr != nil && response.len > 0 {
|
||||
rawResponse = C.GoBytes(response.ptr, C.int(response.len))
|
||||
}
|
||||
if response.ptr != nil {
|
||||
C.free_host_buffer(response.ptr, response.len)
|
||||
}
|
||||
if len(rawResponse) == 0 {
|
||||
return nil, fmt.Errorf("host callback %s returned no response, code=%d", method, int(callCode))
|
||||
}
|
||||
|
||||
var env envelope
|
||||
if errUnmarshal := json.Unmarshal(rawResponse, &env); errUnmarshal != nil {
|
||||
return nil, fmt.Errorf("decode host callback envelope %s: %w", method, errUnmarshal)
|
||||
}
|
||||
if !env.OK {
|
||||
if env.Error != nil {
|
||||
return nil, fmt.Errorf("%s: %s", env.Error.Code, env.Error.Message)
|
||||
}
|
||||
return nil, fmt.Errorf("host callback %s failed", method)
|
||||
}
|
||||
if callCode != 0 {
|
||||
return nil, fmt.Errorf("host callback %s returned code=%d", method, int(callCode))
|
||||
}
|
||||
return append(json.RawMessage(nil), env.Result...), nil
|
||||
}
|
||||
|
||||
func htmlResponse(statusCode int, body []byte) managementResponse {
|
||||
return managementResponse{
|
||||
StatusCode: statusCode,
|
||||
Headers: http.Header{
|
||||
"content-type": []string{resourceContentType},
|
||||
},
|
||||
Body: body,
|
||||
}
|
||||
}
|
||||
|
||||
func renderPage(opts runOptions, status int, headers http.Header, body []byte, chunks []string, errText string, closeMode string, closeError string) []byte {
|
||||
var out bytes.Buffer
|
||||
out.WriteString("<!doctype html><html><head><meta charset=\"utf-8\"><title>Host Model Callback</title>")
|
||||
out.WriteString("<style>body{font-family:-apple-system,BlinkMacSystemFont,\"Segoe UI\",sans-serif;margin:2rem;line-height:1.45;color:#1f2933}code,pre{background:#f3f4f6;border-radius:6px}code{padding:.1rem .3rem}pre{padding:1rem;overflow:auto;white-space:pre-wrap}dl{display:grid;grid-template-columns:max-content 1fr;gap:.35rem 1rem}dt{font-weight:600}dd{margin:0}.error{color:#b42318}</style>")
|
||||
out.WriteString("</head><body><main>")
|
||||
out.WriteString("<h1>Host Model Callback</h1>")
|
||||
out.WriteString("<dl>")
|
||||
writeDefinition(&out, "model", opts.Model)
|
||||
writeDefinition(&out, "mode", opts.Mode)
|
||||
writeDefinition(&out, "entry_protocol", opts.EntryProtocol)
|
||||
writeDefinition(&out, "exit_protocol", opts.ExitProtocol)
|
||||
writeDefinition(&out, "stream", strconv.FormatBool(opts.Stream))
|
||||
writeDefinition(&out, "implicit_close", strconv.FormatBool(opts.ImplicitClose))
|
||||
if closeMode != "" {
|
||||
writeDefinition(&out, "close", closeMode)
|
||||
}
|
||||
writeDefinition(&out, "status", strconv.Itoa(status))
|
||||
out.WriteString("</dl>")
|
||||
if errText != "" {
|
||||
out.WriteString("<h2>Error</h2><pre class=\"error\">")
|
||||
out.WriteString(html.EscapeString(errText))
|
||||
out.WriteString("</pre>")
|
||||
}
|
||||
if closeError != "" {
|
||||
out.WriteString("<h2>Close Error</h2><pre class=\"error\">")
|
||||
out.WriteString(html.EscapeString(closeError))
|
||||
out.WriteString("</pre>")
|
||||
}
|
||||
if headers != nil {
|
||||
out.WriteString("<h2>Headers</h2><pre>")
|
||||
out.WriteString(html.EscapeString(prettyJSON(headers)))
|
||||
out.WriteString("</pre>")
|
||||
}
|
||||
if len(chunks) > 0 {
|
||||
out.WriteString("<h2>Stream Chunks</h2><pre>")
|
||||
out.WriteString(html.EscapeString(strings.Join(chunks, "")))
|
||||
out.WriteString("</pre>")
|
||||
}
|
||||
if len(body) > 0 {
|
||||
out.WriteString("<h2>Body</h2><pre>")
|
||||
out.WriteString(html.EscapeString(prettyBody(body)))
|
||||
out.WriteString("</pre>")
|
||||
}
|
||||
out.WriteString("</main></body></html>")
|
||||
return out.Bytes()
|
||||
}
|
||||
|
||||
func writeDefinition(out *bytes.Buffer, key string, value string) {
|
||||
out.WriteString("<dt>")
|
||||
out.WriteString(html.EscapeString(key))
|
||||
out.WriteString("</dt><dd><code>")
|
||||
out.WriteString(html.EscapeString(value))
|
||||
out.WriteString("</code></dd>")
|
||||
}
|
||||
|
||||
func prettyBody(raw []byte) string {
|
||||
var buf bytes.Buffer
|
||||
if errIndent := json.Indent(&buf, raw, "", " "); errIndent == nil {
|
||||
return buf.String()
|
||||
}
|
||||
return string(raw)
|
||||
}
|
||||
|
||||
func prettyJSON(v any) string {
|
||||
raw, errMarshal := json.MarshalIndent(v, "", " ")
|
||||
if errMarshal != nil {
|
||||
return fmt.Sprintf("%v", v)
|
||||
}
|
||||
return string(raw)
|
||||
}
|
||||
|
||||
func okEnvelope(v any) ([]byte, error) {
|
||||
raw, errMarshal := json.Marshal(v)
|
||||
if errMarshal != nil {
|
||||
return nil, errMarshal
|
||||
}
|
||||
return json.Marshal(envelope{OK: true, Result: raw})
|
||||
}
|
||||
|
||||
func errorEnvelope(code, message string) []byte {
|
||||
raw, _ := json.Marshal(envelope{OK: false, Error: &envelopeError{Code: code, Message: message}})
|
||||
return raw
|
||||
}
|
||||
|
||||
func writeResponse(response *C.cliproxy_buffer, raw []byte) {
|
||||
if response == nil || len(raw) == 0 {
|
||||
return
|
||||
}
|
||||
ptr := C.CBytes(raw)
|
||||
if ptr == nil {
|
||||
return
|
||||
}
|
||||
response.ptr = ptr
|
||||
response.len = C.size_t(len(raw))
|
||||
}
|
||||
|
||||
func cloneHeader(headers http.Header) http.Header {
|
||||
if headers == nil {
|
||||
return nil
|
||||
}
|
||||
cloned := make(http.Header, len(headers))
|
||||
for key, values := range headers {
|
||||
cloned[key] = append([]string(nil), values...)
|
||||
}
|
||||
return cloned
|
||||
}
|
||||
|
||||
func cloneValues(values url.Values) url.Values {
|
||||
if values == nil {
|
||||
return nil
|
||||
}
|
||||
cloned := make(url.Values, len(values))
|
||||
for key, items := range values {
|
||||
cloned[key] = append([]string(nil), items...)
|
||||
}
|
||||
return cloned
|
||||
}
|
||||
Reference in New Issue
Block a user