package main import (	"context"	"encoding/json"	"fmt"	"net/http"	"net/url"	"strings"	"sync" 	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginapi") // Register is called once when the host first loads this .so file.func Register(configYAML []byte) pluginapi.Plugin {	return buildPlugin(configYAML)} // Reconfigure is called on config hot reload while this plugin remains enabled.func Reconfigure(configYAML []byte) pluginapi.Plugin {	return buildPlugin(configYAML)} func buildPlugin(configYAML []byte) pluginapi.Plugin {	example := &examplePlugin{configYAML: append([]byte(nil), configYAML...)}	return pluginapi.Plugin{		Metadata: pluginapi.Metadata{			Name:             "example",			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{				{					Name:        "config1",					Type:        pluginapi.ConfigFieldTypeBoolean,					Description: "Enables the example boolean option.",				},				{					Name:        "config2",					Type:        pluginapi.ConfigFieldTypeString,					Description: "Stores the example string option.",				},				{					Name:        "config3",					Type:        pluginapi.ConfigFieldTypeInteger,					Description: "Stores the example integer option.",				},				{					Name:        "mode",					Type:        pluginapi.ConfigFieldTypeEnum,					EnumValues:  []string{"safe", "fast"},					Description: "Selects the example execution mode.",				},			},		},		Capabilities: pluginapi.Capabilities{			ModelProvider:            example,			AuthProvider:             example,			FrontendAuthProvider:     example,			Executor:                 example,			ExecutorModelScope:       pluginapi.ExecutorModelScopeBoth,			RequestTranslator:        example,			RequestNormalizer:        example,			ResponseTranslator:       example,			ResponseBeforeTranslator: example,			ResponseAfterTranslator:  example,			ThinkingApplier:          example,			UsagePlugin:              example,			CommandLinePlugin:        example,			ManagementAPI:            example,		},	}} type examplePlugin struct {	configYAML []byte	mu         sync.Mutex	usageCount int64} var _ pluginapi.AuthProvider = (*examplePlugin)(nil)var _ pluginapi.ModelProvider = (*examplePlugin)(nil)var _ pluginapi.ProviderExecutor = (*examplePlugin)(nil)var _ pluginapi.ThinkingApplier = (*examplePlugin)(nil) // Native logic always has higher priority than plugin logic.// Native model registration always runs before plugin model discovery.// Executor-backed plugin models can be static, OAuth auth-bound, or both.func (p *examplePlugin) StaticModels(context.Context, pluginapi.StaticModelRequest) (pluginapi.ModelResponse, error) {	return pluginapi.ModelResponse{		Provider: "plugin-example",		Models: []pluginapi.ModelInfo{{			ID:                         "plugin-example-model",			Object:                     "model",			OwnedBy:                    "plugin-example",			Type:                       "chat",			DisplayName:                "Plugin Example Model",			Name:                       "plugin-example-model",			Version:                    "0.1.0",			Description:                "Deterministic example model provided by a Go dynamic plugin.",			InputTokenLimit:            4096,			OutputTokenLimit:           1024,			SupportedGenerationMethods: []string{"generateContent", "chat.completions"},			ContextLength:              4096,			MaxCompletionTokens:        1024,			SupportedParameters:        []string{"model", "messages", "stream", "thinking", "reasoning_effort"},			SupportedInputModalities:   []string{"text"},			SupportedOutputModalities:  []string{"text"},			Thinking:                   &pluginapi.ThinkingSupport{ZeroAllowed: true, DynamicAllowed: true},			UserDefined:                true,		}},	}, nil} func (p *examplePlugin) ModelsForAuth(ctx context.Context, req pluginapi.AuthModelRequest) (pluginapi.ModelResponse, error) {	return p.StaticModels(ctx, pluginapi.StaticModelRequest{Plugin: req.Plugin, Host: req.Host})} func (p *examplePlugin) Identifier() string {	return "plugin-example"} func (p *examplePlugin) ParseAuth(ctx context.Context, req pluginapi.AuthParseRequest) (pluginapi.AuthParseResponse, error) {	if !strings.EqualFold(req.Provider, "plugin-example") {		return pluginapi.AuthParseResponse{}, nil	}	return pluginapi.AuthParseResponse{		Handled: true,		Auth: pluginapi.AuthData{			Provider:    "plugin-example",			ID:          req.FileName,			FileName:    req.FileName,			Label:       "Plugin Example",			StorageJSON: append([]byte(nil), req.RawJSON...),			Metadata: map[string]any{				"type": "plugin-example",			},		},	}, nil} func (p *examplePlugin) StartLogin(context.Context, pluginapi.AuthLoginStartRequest) (pluginapi.AuthLoginStartResponse, error) {	return pluginapi.AuthLoginStartResponse{}, fmt.Errorf("plugin-example login is not interactive")} func (p *examplePlugin) PollLogin(context.Context, pluginapi.AuthLoginPollRequest) (pluginapi.AuthLoginPollResponse, error) {	return pluginapi.AuthLoginPollResponse{Status: pluginapi.AuthLoginStatusError, Message: "plugin-example login is not interactive"}, nil} func (p *examplePlugin) RefreshAuth(ctx context.Context, req pluginapi.AuthRefreshRequest) (pluginapi.AuthRefreshResponse, error) {	return pluginapi.AuthRefreshResponse{		Auth: pluginapi.AuthData{			Provider:    req.AuthProvider,			ID:          req.AuthID,			StorageJSON: append([]byte(nil), req.StorageJSON...),			Metadata:    cloneAnyMap(req.Metadata),			Attributes:  cloneStringMap(req.Attributes),		},	}, nil} // A plugin can register multiple command-line flags.// Flags are registered by priority. Existing native flags, reserved help/h flags,// or higher-priority plugin flags win and cannot be registered again.func (p *examplePlugin) RegisterCommandLine(context.Context, pluginapi.CommandLineRegistrationRequest) (pluginapi.CommandLineRegistrationResponse, error) {	return pluginapi.CommandLineRegistrationResponse{		Flags: []pluginapi.CommandLineFlag{			{				Name:         "plugin-example-command",				Usage:        "Run the example plugin command-line handler",				Type:         "bool",				DefaultValue: "false",			},			{				Name:         "plugin-example-message",				Usage:        "Message passed to the example plugin command-line handler",				Type:         "string",				DefaultValue: "hello",			},		},	}, nil} // Global plugins.enabled=false or per-plugin enabled=false skips command-line execution after reload.// The host passes every command-line argument and all triggered plugin flags to ExecuteCommandLine.func (p *examplePlugin) ExecuteCommandLine(ctx context.Context, req pluginapi.CommandLineExecutionRequest) (pluginapi.CommandLineExecutionResponse, error) {	message := req.Flags["plugin-example-message"].Value	if triggeredMessage, ok := req.TriggeredFlags["plugin-example-message"]; ok {		message = triggeredMessage.Value	}	return pluginapi.CommandLineExecutionResponse{		Stdout: []byte(fmt.Sprintf("example plugin command executed with %d argument(s), message=%q\n", len(req.Args), message)),	}, nil} // A plugin can register multiple Management API routes.// Management API routes are exact routes under /v0/management/ and cannot override// native routes or higher-priority plugin routes that are already registered.func (p *examplePlugin) RegisterManagement(context.Context, pluginapi.ManagementRegistrationRequest) (pluginapi.ManagementRegistrationResponse, error) {	return pluginapi.ManagementRegistrationResponse{		Routes: []pluginapi.ManagementRoute{			{				Method:      http.MethodGet,				Path:        "/plugins/example/status",				Menu:        "Example Status",				Description: "Shows example plugin runtime status.",				Handler:     p,			},			{				Method:      http.MethodGet,				Path:        "/plugins/example/capabilities",				Menu:        "Example Capabilities",				Description: "Shows example plugin capability details.",				Handler:     p,			},		},	}, nil} // Plugin Management API routes still require the normal Management API key,// and are skipped when Home mode or Management API availability disables them.func (p *examplePlugin) HandleManagement(ctx context.Context, req pluginapi.ManagementRequest) (pluginapi.ManagementResponse, error) {	p.mu.Lock()	usageCount := p.usageCount	p.mu.Unlock() 	body := []byte(fmt.Sprintf(`{"plugin":"example","usage_count":%d}`+"\n", usageCount))	if strings.HasSuffix(req.Path, "/capabilities") {		body = []byte(`{"plugin":"example","capabilities":["command-line","management-api","auth-provider","model-provider","frontend-auth","executor","raw-http","request-translator","request-normalizer","response-translator","response-normalizer","thinking-applier","usage"]}` + "\n")	} 	return pluginapi.ManagementResponse{		StatusCode: http.StatusOK,		Headers: http.Header{			"Content-Type": []string{"application/json"},		},		Body: body,	}, nil} // Global plugins.enabled=false or per-plugin enabled=false skips plugin execution after reload.func (p *examplePlugin) Authenticate(ctx context.Context, req pluginapi.FrontendAuthRequest) (pluginapi.FrontendAuthResponse, error) {	authenticated := req.Headers.Get("X-Plugin-Example") == "allow"	if !authenticated {		return pluginapi.FrontendAuthResponse{}, nil	} 	return pluginapi.FrontendAuthResponse{		Authenticated: true,		Principal:     "plugin-example-user",		Metadata: map[string]string{			"provider": "plugin-example",		},	}, nil} // A plugin executor runs only for a matching auth when no native executor owns the provider.func (p *examplePlugin) Execute(context.Context, pluginapi.ExecutorRequest) (pluginapi.ExecutorResponse, error) {	return pluginapi.ExecutorResponse{		Payload: []byte(`{"id":"plugin-example-response","object":"chat.completion","model":"plugin-example-model","choices":[{"index":0,"message":{"role":"assistant","content":"plugin example response"},"finish_reason":"stop"}]}`),		Headers: http.Header{			"Content-Type": []string{"application/json"},		},		Metadata: map[string]any{			"provider": "plugin-example",		},	}, nil} func (p *examplePlugin) ExecuteStream(context.Context, pluginapi.ExecutorRequest) (pluginapi.ExecutorStreamResponse, error) {	chunks := make(chan pluginapi.ExecutorStreamChunk, 1)	chunks <- pluginapi.ExecutorStreamChunk{		Payload: []byte(`{"id":"plugin-example-stream","object":"chat.completion.chunk","model":"plugin-example-model","choices":[{"index":0,"delta":{"content":"plugin example response"},"finish_reason":"stop"}]}`),	}	close(chunks) 	return pluginapi.ExecutorStreamResponse{		Headers: http.Header{			"Content-Type": []string{"application/json"},		},		Chunks: chunks,	}, nil} func (p *examplePlugin) CountTokens(context.Context, pluginapi.ExecutorRequest) (pluginapi.ExecutorResponse, error) {	return pluginapi.ExecutorResponse{		Payload: []byte(`{"input_tokens":0,"output_tokens":0,"total_tokens":0}`),		Headers: http.Header{			"Content-Type": []string{"application/json"},		},	}, nil} func (p *examplePlugin) HttpRequest(ctx context.Context, req pluginapi.ExecutorHTTPRequest) (pluginapi.ExecutorHTTPResponse, error) {	resp, errDo := req.HTTPClient.Do(ctx, pluginapi.HTTPRequest{		Method:  req.Method,		URL:     req.URL,		Headers: req.Headers,		Body:    req.Body,	})	if errDo != nil {		return pluginapi.ExecutorHTTPResponse{}, errDo	}	return pluginapi.ExecutorHTTPResponse{		StatusCode: resp.StatusCode,		Headers:    resp.Headers,		Body:       resp.Body,	}, nil} // Request/response translators run only when no native translator exists, and only the highest-priority plugin translator runs once.func (p *examplePlugin) TranslateRequest(ctx context.Context, req pluginapi.RequestTransformRequest) (pluginapi.PayloadResponse, error) {	return payloadOrEmptyObject(req.Body), nil} // Normalizers run from higher priority to lower priority and are chained.func (p *examplePlugin) NormalizeRequest(ctx context.Context, req pluginapi.RequestTransformRequest) (pluginapi.PayloadResponse, error) {	return payloadOrEmptyObject(req.Body), nil} func (p *examplePlugin) TranslateResponse(ctx context.Context, req pluginapi.ResponseTransformRequest) (pluginapi.PayloadResponse, error) {	return payloadOrEmptyObject(req.Body), nil} func (p *examplePlugin) NormalizeResponse(ctx context.Context, req pluginapi.ResponseTransformRequest) (pluginapi.PayloadResponse, error) {	return payloadOrEmptyObject(req.Body), nil} func (p *examplePlugin) ApplyThinking(ctx context.Context, req pluginapi.ThinkingApplyRequest) (pluginapi.PayloadResponse, error) {	var payload map[string]any	if len(req.Body) == 0 {		payload = map[string]any{}	} else if errUnmarshal := json.Unmarshal(req.Body, &payload); errUnmarshal != nil {		return pluginapi.PayloadResponse{}, errUnmarshal	}	payload["plugin_example_thinking"] = map[string]any{		"mode":   req.Config.Mode,		"budget": req.Config.Budget,		"level":  req.Config.Level,	}	out, errMarshal := json.Marshal(payload)	if errMarshal != nil {		return pluginapi.PayloadResponse{}, errMarshal	}	return pluginapi.PayloadResponse{Body: out}, nil} // If any plugin method panics, host disables that plugin for current process lifetime and never calls it again until restart.func (p *examplePlugin) HandleUsage(ctx context.Context, record pluginapi.UsageRecord) {	p.mu.Lock()	defer p.mu.Unlock() 	p.usageCount++} func payloadOrEmptyObject(body []byte) pluginapi.PayloadResponse {	if len(body) == 0 {		return pluginapi.PayloadResponse{Body: []byte(`{}`)}	} 	return pluginapi.PayloadResponse{Body: append([]byte(nil), body...)}} func cloneAnyMap(src map[string]any) map[string]any {	if len(src) == 0 {		return nil	}	dst := make(map[string]any, len(src))	for key, value := range src {		dst[key] = cloneAnyValue(value)	}	return dst} func cloneAnyValue(value any) any {	switch typed := value.(type) {	case map[string]any:		return cloneAnyMap(typed)	case map[string]string:		return cloneStringMap(typed)	case []any:		out := make([]any, len(typed))		for i, item := range typed {			out[i] = cloneAnyValue(item)		}		return out	case []string:		return append([]string(nil), typed...)	case http.Header:		return typed.Clone()	case url.Values:		return cloneValues(typed)	default:		return value	}} func cloneStringMap(src map[string]string) map[string]string {	if len(src) == 0 {		return nil	}	dst := make(map[string]string, len(src))	for key, value := range src {		dst[key] = value	}	return dst} func cloneValues(src url.Values) url.Values {	if len(src) == 0 {		return nil	}	dst := make(url.Values, len(src))	for key, values := range src {		dst[key] = append([]string(nil), values...)	}	return dst}