Adding a TextFilePrompt method to support issue #1. This method generates text file prompt data when the request is too large.

The method result logic has been changed; it is now a global variable throughout the lifespan of the all-runner, particularly within sub-runners.

Author: luispater

internal/api/handlers.go

@@ -153,7 +153,7 @@ func (h *APIHandlers) ChatCompletions(c *gin.Context) {
 
 func (h *APIHandlers) handleContextCanceled(instanceIndex int) {
 	page := h.pages[h.appConfig.Instance[instanceIndex].Name]
-	r, err := runner.NewRunnerManager(h.appConfig.Instance[instanceIndex].Name, h.appConfig.Instance[instanceIndex].Runner, page, h.debug)
+	r, err := runner.NewRunnerManager(h.appConfig.Instance[instanceIndex], page, h.debug)
 	if err != nil {
 		log.Error(err)
 		return

internal/api/processor.go

@@ -46,32 +46,32 @@ func (cp *ChatProcessor) ProcessTask(ctx context.Context, task *RequestTask) *Ta
 		}
 	}
 
-	var appConfigRunner config.AppConfigRunner
+	var appConfigInstance config.AppConfigInstance
 	for i := 0; i < len(cp.appConfig.Instance); i++ {
 		if cp.appConfig.Instance[i].Name == instanceName {
-			appConfigRunner = cp.appConfig.Instance[i].Runner
+			appConfigInstance = cp.appConfig.Instance[i]
 		}
 	}
 
 	streamResult := gjson.Get(task.Request, "stream")
 	if streamResult.Type == gjson.True {
-		return cp.processStreamingTask(instanceName, appConfigRunner, ctx, task)
+		return cp.processStreamingTask(appConfigInstance, ctx, task)
 	} else {
-		return cp.processNonStreamingTask(instanceName, appConfigRunner, ctx, task)
+		return cp.processNonStreamingTask(appConfigInstance, ctx, task)
 	}
 }
 
 // processNonStreamingTask processes a non-streaming request
-func (cp *ChatProcessor) processNonStreamingTask(instanceName string, appConfigRunner config.AppConfigRunner, ctx context.Context, task *RequestTask) *TaskResponse {
+func (cp *ChatProcessor) processNonStreamingTask(appConfigInstance config.AppConfigInstance, ctx context.Context, task *RequestTask) *TaskResponse {
 
 	var fullResponse strings.Builder
 	var done bool
 	channel := make(chan *adapter.AdapterResponse)
 	errChannel := make(chan error)
 	streamChan := make(chan string, 100)
 
-	page := cp.pages[instanceName]
-	r, errNewRunnerManager := runner.NewRunnerManager(instanceName, appConfigRunner, page, cp.debug)
+	page := cp.pages[appConfigInstance.Name]
+	r, errNewRunnerManager := runner.NewRunnerManager(appConfigInstance, page, cp.debug)
 	go func() {
 		if errNewRunnerManager != nil {
 			log.Debug(errNewRunnerManager)
@@ -154,14 +154,14 @@ func (cp *ChatProcessor) processNonStreamingTask(instanceName string, appConfigR
 }
 
 // processStreamingTask processes a streaming request
-func (cp *ChatProcessor) processStreamingTask(instanceName string, appConfigRunner config.AppConfigRunner, ctx context.Context, task *RequestTask) *TaskResponse {
+func (cp *ChatProcessor) processStreamingTask(appConfigInstance config.AppConfigInstance, ctx context.Context, task *RequestTask) *TaskResponse {
 	// Create streaming channel
 	streamChan := make(chan string, 100)
 	channel := make(chan *adapter.AdapterResponse)
 	errChannel := make(chan error)
 
-	page := cp.pages[instanceName]
-	r, errNewRunnerManager := runner.NewRunnerManager(instanceName, appConfigRunner, page, cp.debug)
+	page := cp.pages[appConfigInstance.Name]
+	r, errNewRunnerManager := runner.NewRunnerManager(appConfigInstance, page, cp.debug)
 	go func() {
 		if errNewRunnerManager != nil {
 			log.Debug(errNewRunnerManager)

internal/config/config.go

@@ -26,14 +26,15 @@ type AppConfigRunner struct {
 	ContextCanceled string `yaml:"context_canceled"`
 }
 type AppConfigInstance struct {
-	Name      string                `yaml:"name"`
-	Adapter   string                `yaml:"adapter"`
-	ProxyURL  string                `yaml:"proxy-url"`
-	URL       string                `yaml:"url"`
-	SniffURL  []string              `yaml:"sniff-url"`
-	UserAgent string                `yaml:"user-agent,omitempty"`
-	Auth      AppConfigInstanceAuth `yaml:"auth"`
-	Runner    AppConfigRunner       `yaml:"runner"`
+	Name                  string                `yaml:"name"`
+	Adapter               string                `yaml:"adapter"`
+	ProxyURL              string                `yaml:"proxy-url"`
+	TextFilePromptMinSize int                   `yaml:"text-file-prompt-min-size"`
+	URL                   string                `yaml:"url"`
+	SniffURL              []string              `yaml:"sniff-url"`
+	UserAgent             string                `yaml:"user-agent,omitempty"`
+	Auth                  AppConfigInstanceAuth `yaml:"auth"`
+	Runner                AppConfigRunner       `yaml:"runner"`
 }
 
 type AppConfigInstanceAuth struct {

internal/method/request.go

@@ -1,6 +1,7 @@
 package method
 
 import (
+	"encoding/base64"
 	"fmt"
 	log "github.com/sirupsen/logrus"
 	"github.com/tidwall/gjson"
@@ -418,3 +419,16 @@ func (m *Method) Tools(requestJson string) (bool, string, error) {
 	}
 	return true, "[]", nil
 }
+
+func (m *Method) TextFilePrompt(requestJson string, maxSize int) (bool, []string, error) {
+	if maxSize > 0 {
+		prompt, err := m.BuildPrompt(requestJson, true)
+		if err != nil {
+			return false, []string{}, err
+		}
+		if len(prompt) > maxSize {
+			return true, []string{fmt.Sprintf("data:text/plain;base64,%s", base64.StdEncoding.EncodeToString([]byte(prompt)))}, nil
+		}
+	}
+	return false, []string{}, nil
+}

internal/runner/manager.go

@@ -22,32 +22,35 @@ type RunnerResult struct {
 }
 
 type RunnerManager struct {
-	name            string
-	page            *chrome.Page
-	configs         map[string]Configuration
-	method          *method.Method
-	results         map[string]RunnerResult
-	debug           bool
-	debugConfigs    map[string]string
-	appConfigRunner config.AppConfigRunner
-	abort           bool
+	appConfigInstance config.AppConfigInstance
+	page              *chrome.Page
+	configs           map[string]Configuration
+	method            *method.Method
+	results           map[string]RunnerResult
+	debug             bool
+	debugConfigs      map[string]string
+	abort             bool
 }
 
-func NewRunnerManager(name string, appConfigRunner config.AppConfigRunner, page *chrome.Page, debug bool) (*RunnerManager, error) {
+func NewRunnerManager(appConfigInstance config.AppConfigInstance, page *chrome.Page, debug bool, results ...map[string]RunnerResult) (*RunnerManager, error) {
+	if len(results) == 0 {
+		results = []map[string]RunnerResult{make(map[string]RunnerResult)}
+	}
+
 	runner := &RunnerManager{
-		name:            name,
-		page:            page,
-		method:          method.NewMethod(page),
-		configs:         make(map[string]Configuration),
-		results:         make(map[string]RunnerResult),
-		debug:           debug,
-		debugConfigs:    make(map[string]string),
-		appConfigRunner: appConfigRunner,
+		appConfigInstance: appConfigInstance,
+		page:              page,
+		method:            method.NewMethod(page),
+		configs:           make(map[string]Configuration),
+		results:           results[0],
+		debug:             debug,
+		debugConfigs:      make(map[string]string),
 	}
 	err := runner.LoadConfigurations()
 	if err != nil {
 		return nil, err
 	}
+	runner.SetVariable("TextFilePromptMinSize", appConfigInstance.TextFilePromptMinSize, "int")
 	return runner, nil
 }
 
@@ -115,13 +118,13 @@ func (rm *RunnerManager) LoadConfiguration(name, path string) error {
 // LoadConfigurations scans all yaml files in the runner directory and calls LoadConfiguration method by filename
 func (rm *RunnerManager) LoadConfigurations() error {
 	// Scan all yaml and yml files in the runner directory
-	pattern := filepath.Join("runner", rm.name, "*.yaml")
+	pattern := filepath.Join("runner", rm.appConfigInstance.Name, "*.yaml")
 	yamlFiles, err := filepath.Glob(pattern)
 	if err != nil {
 		return fmt.Errorf("failed to scan yaml files: %v", err)
 	}
 
-	pattern = filepath.Join("runner", rm.name, "*.yml")
+	pattern = filepath.Join("runner", rm.appConfigInstance.Name, "*.yml")
 	ymlFiles, err := filepath.Glob(pattern)
 	if err != nil {
 		return fmt.Errorf("failed to scan yml files: %v", err)
@@ -138,11 +141,11 @@ func (rm *RunnerManager) LoadConfigurations() error {
 		name := strings.TrimSuffix(fileName, filepath.Ext(fileName))
 
 		switch name {
-		case rm.appConfigRunner.Init:
+		case rm.appConfigInstance.Runner.Init:
 			name = "init"
-		case rm.appConfigRunner.ChatCompletions:
+		case rm.appConfigInstance.Runner.ChatCompletions:
 			name = "chat_completions"
-		case rm.appConfigRunner.ContextCanceled:
+		case rm.appConfigInstance.Runner.ContextCanceled:
 			name = "context_canceled"
 		}
 
@@ -219,7 +222,7 @@ outLoop:
 		}
 
 		if workflows[executeIndex].Action == "DoRunner" {
-			r, err := NewRunnerManager(rm.name, rm.appConfigRunner, rm.page, rm.debug)
+			r, err := NewRunnerManager(rm.appConfigInstance, rm.page, rm.debug, rm.results)
 			if err != nil {
 				log.Error(err)
 				return err
@@ -315,6 +318,8 @@ outLoop:
 					doFailback = true
 				} else if rule == "FAILED" {
 					return fmt.Errorf("workflow failed")
+				} else if rule == "FINISH" {
+					return fmt.Errorf("workflow done")
 				} else if strings.HasPrefix(rule, "DO-WORKFLOW-IDX:") {
 					log.Debugf("DO-WORKFLOW-IDX: %s", rule[16:])
 					// Handle DO-WORKFLOW-IDX:1,2,3 cases
@@ -386,6 +391,8 @@ outLoop:
 					continue outLoop
 				} else if err.Error() == "workflow failed" {
 					return err
+				} else if err.Error() == "workflow done" {
+					return nil
 				}
 
 				// sub workflow failed, need to retry
@@ -503,7 +510,7 @@ func (rm *RunnerManager) executeMethod(obj any, methodName string, params []inte
 			input := strings.TrimSpace(reflect.ValueOf(params[i-1]).String())
 			if len(input) > 2 && input[0] == '#' && input[len(input)-1] == '#' {
 				if input == "#NEW_RUNNER#" {
-					newRm, _ := NewRunnerManager(rm.name, rm.appConfigRunner, rm.page, rm.debug)
+					newRm, _ := NewRunnerManager(rm.appConfigInstance, rm.page, rm.debug, rm.results)
 					args[paramIndex] = reflect.ValueOf(newRm)
 				} else {
 					input = input[1 : len(input)-1]

main.go

@@ -2,26 +2,23 @@ package main
 
 import (
 	"bytes"
-	"context" // Will be needed for marshalling cookies
+	"context"
 	"encoding/json"
 	"fmt"
 	"github.com/chromedp/cdproto/cdp"
+	"github.com/chromedp/chromedp"
+	"github.com/luispater/anyAIProxyAPI/internal/api"
+	"github.com/luispater/anyAIProxyAPI/internal/browser/chrome"
+	chromedpmanager "github.com/luispater/anyAIProxyAPI/internal/browser/chrome"
+	"github.com/luispater/anyAIProxyAPI/internal/config"
 	"github.com/luispater/anyAIProxyAPI/internal/runner"
+	log "github.com/sirupsen/logrus"
 	"os"
 	"os/signal"
 	"path"
 	"path/filepath"
 	"syscall"
 	"time"
-
-	// For cdp.Node
-	"github.com/chromedp/chromedp" // For chromedp actions
-	"github.com/luispater/anyAIProxyAPI/internal/api"
-	"github.com/luispater/anyAIProxyAPI/internal/browser/chrome"
-	chromedpmanager "github.com/luispater/anyAIProxyAPI/internal/browser/chrome"
-	"github.com/luispater/anyAIProxyAPI/internal/config"
-	// "github.com/playwright-community/playwright-go" // Playwright no longer used
-	log "github.com/sirupsen/logrus"
 )
 
 type LogFormatter struct {
@@ -124,7 +121,7 @@ func main() {
 
 		pages[cfg.Instance[i].Name] = page // Store pageCtx
 
-		r, errNewRunnerManager := runner.NewRunnerManager(cfg.Instance[i].Name, cfg.Instance[i].Runner, page, cfg.Debug) // Pass pageCtx
+		r, errNewRunnerManager := runner.NewRunnerManager(cfg.Instance[i], page, cfg.Debug) // Pass pageCtx
 		if errNewRunnerManager != nil {
 			log.Error(errNewRunnerManager)
 		}