diff --git a/.golangci.yml b/.golangci.yml index e91a9ccc..0f992df5 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -1,24 +1,41 @@ +version: "2" run: timeout: 5m - output: formats: - - format: colored-line-number - + text: + path: stdout linters: - disable-all: true + default: none enable: - - errcheck - - gofmt - - gosimple - - govet - - ineffassign - - staticcheck - - typecheck - - thelper - - unused - - goimports - - whitespace - - revive - fast: false + - errcheck + - govet + - ineffassign + - revive + - staticcheck + - thelper + - unused + - whitespace + exclusions: + generated: lax + presets: + - comments + - common-false-positives + - legacy + - std-error-handling + paths: + - third_party$ + - builtin$ + - examples$ +issues: max-same-issues: 50 +formatters: + enable: + - gofmt + - goimports + exclusions: + generated: lax + paths: + - third_party$ + - builtin$ + - examples$ diff --git a/Makefile b/Makefile index 4a52694a..b2e8482a 100644 --- a/Makefile +++ b/Makefile @@ -22,7 +22,7 @@ smoke: build smoke: go test -v -tags='smoke' ./pkg/tests/smoke/... -GOLANGCI_LINT_VERSION ?= v1.60.1 +GOLANGCI_LINT_VERSION ?= v2.1.2 lint: if ! command -v golangci-lint &> /dev/null; then \ echo "Could not find golangci-lint, installing version $(GOLANGCI_LINT_VERSION)."; \ diff --git a/pkg/builtin/builtin.go b/pkg/builtin/builtin.go index d14fe7c7..b339b52a 100644 --- a/pkg/builtin/builtin.go +++ b/pkg/builtin/builtin.go @@ -280,8 +280,8 @@ func DefaultModel(name, defaultModel string) (types.Tool, bool) { // Legacy syntax not used anymore name = strings.TrimSuffix(name, "?") t, ok := tools[name] - t.Parameters.Name = name - t.Parameters.ModelName = defaultModel + t.Name = name + t.ModelName = defaultModel t.ID = name t.Instructions = "#!" + name return SetDefaults(t), ok diff --git a/pkg/builtin/defaults.go b/pkg/builtin/defaults.go index ac264ae6..85bdf485 100644 --- a/pkg/builtin/defaults.go +++ b/pkg/builtin/defaults.go @@ -18,8 +18,8 @@ func SetDefaultModel(model string) { } func SetDefaults(tool types.Tool) types.Tool { - if tool.Parameters.ModelName == "" { - tool.Parameters.ModelName = GetDefaultModel() + if tool.ModelName == "" { + tool.ModelName = GetDefaultModel() } return tool } diff --git a/pkg/chat/chat.go b/pkg/chat/chat.go index e36f107b..5adc0676 100644 --- a/pkg/chat/chat.go +++ b/pkg/chat/chat.go @@ -61,7 +61,7 @@ func Start(ctx context.Context, prevState runner.ChatState, chatter Chatter, prg if startInput != "" { input = startInput startInput = "" - } else if targetTool := prog.ToolSet[prog.EntryToolID]; !((prevState == nil || prevState == "") && targetTool.Arguments == nil && targetTool.Instructions != "") { + } else if targetTool := prog.ToolSet[prog.EntryToolID]; prevState != nil && prevState != "" || targetTool.Arguments != nil || targetTool.Instructions == "" { // The above logic will skip prompting if this is the first loop and the chat expects no args input, ok, err = prompter.Readline() if !ok || err != nil { diff --git a/pkg/cli/gptscript.go b/pkg/cli/gptscript.go index 718c6f90..4b0642d2 100644 --- a/pkg/cli/gptscript.go +++ b/pkg/cli/gptscript.go @@ -366,7 +366,7 @@ func (r *GPTScript) Run(cmd *cobra.Command, args []string) (retErr error) { // If the file is external, then set the SCRIPTS_PATH to the current working directory. Otherwise, // set it to the directory of the script and set the file to the base. - if !(strings.HasPrefix(file, "http://") || strings.HasPrefix(file, "https://") || strings.HasPrefix(file, "github.com")) { + if !strings.HasPrefix(file, "http://") && !strings.HasPrefix(file, "https://") && !strings.HasPrefix(file, "github.com") { absPathToScript, err := filepath.Abs(file) if err != nil { return fmt.Errorf("cannot determine absolute path to script %s: %v", file, err) @@ -469,8 +469,8 @@ func (r *GPTScript) Run(cmd *cobra.Command, args []string) (retErr error) { // Don't use cmd.Context() because then sigint will cancel everything return tui.Run(context.Background(), args[0], tui.RunOptions{ ClientOpts: &gptscript2.GlobalOptions{ - OpenAIAPIKey: r.OpenAIOptions.APIKey, - OpenAIBaseURL: r.OpenAIOptions.BaseURL, + OpenAIAPIKey: r.APIKey, + OpenAIBaseURL: r.BaseURL, DefaultModel: r.DefaultModel, DefaultModelProvider: r.DefaultModelProvider, }, diff --git a/pkg/engine/cmd.go b/pkg/engine/cmd.go index 368b1c98..5fb340c5 100644 --- a/pkg/engine/cmd.go +++ b/pkg/engine/cmd.go @@ -171,7 +171,7 @@ func (e *Engine) runCommand(ctx Context, tool types.Tool, input string, toolCate // If this is a sub-call, then don't return the error; return the error as a message so that the LLM can retry. return fmt.Sprintf("ERROR: got (%v) while running tool, OUTPUT: %s", err, stdoutAndErr), nil } - log.Errorf("failed to run tool [%s] cmd %v: %v", tool.Parameters.Name, cmd.Args, err) + log.Errorf("failed to run tool [%s] cmd %v: %v", tool.Name, cmd.Args, err) return "", fmt.Errorf("ERROR: %s: %w", stdoutAndErr, err) } diff --git a/pkg/engine/daemon.go b/pkg/engine/daemon.go index 6f991be0..58de592b 100644 --- a/pkg/engine/daemon.go +++ b/pkg/engine/daemon.go @@ -175,7 +175,7 @@ func (e *Engine) startDaemon(tool types.Tool) (string, error) { return w.Close() } - log.Infof("launched [%s][%s] port [%d] %v", tool.Parameters.Name, tool.ID, port, cmd.Args) + log.Infof("launched [%s][%s] port [%d] %v", tool.Name, tool.ID, port, cmd.Args) if err := cmd.Start(); err != nil { stop() return url, err @@ -195,7 +195,7 @@ func (e *Engine) startDaemon(tool types.Tool) (string, error) { go func() { err := cmd.Wait() if err != nil { - log.Debugf("daemon exited tool [%s] %v: %v", tool.Parameters.Name, cmd.Args, err) + log.Debugf("daemon exited tool [%s] %v: %v", tool.Name, cmd.Args, err) } _ = r.Close() _ = w.Close() diff --git a/pkg/engine/engine.go b/pkg/engine/engine.go index c55f092d..abf45e8c 100644 --- a/pkg/engine/engine.go +++ b/pkg/engine/engine.go @@ -285,13 +285,13 @@ func (c *Context) WrappedContext(e *Engine) context.Context { } func populateMessageParams(ctx Context, completion *types.CompletionRequest, tool types.Tool) error { - completion.Model = tool.Parameters.ModelName - completion.MaxTokens = tool.Parameters.MaxTokens - completion.JSONResponse = tool.Parameters.JSONResponse - completion.Cache = tool.Parameters.Cache - completion.Chat = tool.Parameters.Chat - completion.Temperature = tool.Parameters.Temperature - completion.InternalSystemPrompt = tool.Parameters.InternalPrompt + completion.Model = tool.ModelName + completion.MaxTokens = tool.MaxTokens + completion.JSONResponse = tool.JSONResponse + completion.Cache = tool.Cache + completion.Chat = tool.Chat + completion.Temperature = tool.Temperature + completion.InternalSystemPrompt = tool.InternalPrompt if tool.Chat && completion.InternalSystemPrompt == nil { completion.InternalSystemPrompt = new(bool) diff --git a/pkg/engine/http.go b/pkg/engine/http.go index 9e59b70a..49738b1a 100644 --- a/pkg/engine/http.go +++ b/pkg/engine/http.go @@ -112,7 +112,7 @@ func (e *Engine) runHTTP(ctx Context, tool types.Tool, input string) (cmdRet *Re } } - req.Header.Set("X-GPTScript-Tool-Name", tool.Parameters.Name) + req.Header.Set("X-GPTScript-Tool-Name", tool.Name) if err := json.Unmarshal([]byte(input), &map[string]any{}); err == nil { req.Header.Set("Content-Type", "application/json") diff --git a/pkg/loader/loader.go b/pkg/loader/loader.go index 8e3914b5..e70827c6 100644 --- a/pkg/loader/loader.go +++ b/pkg/loader/loader.go @@ -225,15 +225,15 @@ func readTool(ctx context.Context, cache *cache.Client, prg *types.Program, base // Probably a better way to come up with an ID tool.ID = tool.Source.Location + ":" + tool.Name - if i != 0 && tool.Parameters.Name == "" { + if i != 0 && tool.Name == "" { return nil, parser.NewErrLine(tool.Source.Location, tool.Source.LineNo, fmt.Errorf("only the first tool in a file can have no name")) } - if i != 0 && tool.Parameters.GlobalModelName != "" { + if i != 0 && tool.GlobalModelName != "" { return nil, parser.NewErrLine(tool.Source.Location, tool.Source.LineNo, fmt.Errorf("only the first tool in a file can have global model name")) } - if i != 0 && len(tool.Parameters.GlobalTools) > 0 { + if i != 0 && len(tool.GlobalTools) > 0 { return nil, parser.NewErrLine(tool.Source.Location, tool.Source.LineNo, fmt.Errorf("only the first tool in a file can have global tools")) } @@ -245,8 +245,8 @@ func readTool(ctx context.Context, cache *cache.Client, prg *types.Program, base targetTools = append(targetTools, tool) } - if targetToolName != "" && tool.Parameters.Name != "" { - if strings.EqualFold(tool.Parameters.Name, targetToolName) { + if targetToolName != "" && tool.Name != "" { + if strings.EqualFold(tool.Name, targetToolName) { targetTools = append(targetTools, tool) } else if strings.Contains(targetToolName, "*") { var patterns []string @@ -257,7 +257,7 @@ func readTool(ctx context.Context, cache *cache.Client, prg *types.Program, base } for _, pattern := range patterns { - match, err := filepath.Match(strings.ToLower(pattern), strings.ToLower(tool.Parameters.Name)) + match, err := filepath.Match(strings.ToLower(pattern), strings.ToLower(tool.Name)) if err != nil { return nil, parser.NewErrLine(tool.Source.Location, tool.Source.LineNo, err) } @@ -270,13 +270,13 @@ func readTool(ctx context.Context, cache *cache.Client, prg *types.Program, base } } - if existing, ok := localTools[strings.ToLower(tool.Parameters.Name)]; ok { + if existing, ok := localTools[strings.ToLower(tool.Name)]; ok { return nil, parser.NewErrLine(tool.Source.Location, tool.Source.LineNo, - fmt.Errorf("duplicate tool name [%s] in %s found at lines %d and %d", tool.Parameters.Name, tool.Source.Location, + fmt.Errorf("duplicate tool name [%s] in %s found at lines %d and %d", tool.Name, tool.Source.Location, tool.Source.LineNo, existing.Source.LineNo)) } - localTools[strings.ToLower(tool.Parameters.Name)] = tool + localTools[strings.ToLower(tool.Name)] = tool } return linkAll(ctx, cache, prg, base, targetTools, localTools, defaultModel) @@ -285,7 +285,7 @@ func readTool(ctx context.Context, cache *cache.Client, prg *types.Program, base func linkAll(ctx context.Context, cache *cache.Client, prg *types.Program, base *source, tools []types.Tool, localTools types.ToolSet, defaultModel string) (result []types.Tool, _ error) { localToolsMapping := make(map[string]string, len(tools)) for _, localTool := range localTools { - localToolsMapping[strings.ToLower(localTool.Parameters.Name)] = localTool.ID + localToolsMapping[strings.ToLower(localTool.Name)] = localTool.ID } for _, tool := range tools { @@ -314,7 +314,7 @@ func link(ctx context.Context, cache *cache.Client, prg *types.Program, base *so // The below is done in two loops so that local names stay as the tool names // and don't get mangled by external references - for _, targetToolName := range tool.Parameters.ToolRefNames() { + for _, targetToolName := range tool.ToolRefNames() { noArgs, _ := types.SplitArg(targetToolName) localTool, ok := localTools[strings.ToLower(noArgs)] if ok { diff --git a/pkg/loader/openapi.go b/pkg/loader/openapi.go index e62fc5ef..3ab564e5 100644 --- a/pkg/loader/openapi.go +++ b/pkg/loader/openapi.go @@ -174,11 +174,11 @@ func getOpenAPITools(t *openapi3.T, defaultHost, source, targetToolName string) } // Add the new arg to the tool's arguments - tool.Parameters.Arguments.Properties[param.Value.Name] = &openapi3.SchemaRef{Value: arg} + tool.Arguments.Properties[param.Value.Name] = &openapi3.SchemaRef{Value: arg} // Check whether it is required if param.Value.Required { - tool.Parameters.Arguments.Required = append(tool.Parameters.Arguments.Required, param.Value.Name) + tool.Arguments.Required = append(tool.Arguments.Required, param.Value.Name) } // Add the parameter to the appropriate list for the tool's instructions @@ -227,7 +227,7 @@ func getOpenAPITools(t *openapi3.T, defaultHost, source, targetToolName string) } // Unfortunately, the request body doesn't contain any good descriptor for it, // so we just use "requestBodyContent" as the name of the arg. - tool.Parameters.Arguments.Properties["requestBodyContent"] = &openapi3.SchemaRef{Value: arg} + tool.Arguments.Properties["requestBodyContent"] = &openapi3.SchemaRef{Value: arg} break } @@ -310,7 +310,7 @@ func getOpenAPITools(t *openapi3.T, defaultHost, source, targetToolName string) } // Register - toolNames = append(toolNames, tool.Parameters.Name) + toolNames = append(toolNames, tool.Name) tools = append(tools, tool) operationNum++ } @@ -457,7 +457,7 @@ func getOpenAPIToolsRevamp(t *openapi3.T, source, targetToolName string) ([]type exportTool := types.Tool{ ToolDef: types.ToolDef{ Parameters: types.Parameters{ - Export: []string{list.Parameters.Name, getSchema.Parameters.Name, run.Parameters.Name}, + Export: []string{list.Name, getSchema.Name, run.Name}, }, }, } diff --git a/pkg/monitor/display.go b/pkg/monitor/display.go index 73a15006..6bc6e9f3 100644 --- a/pkg/monitor/display.go +++ b/pkg/monitor/display.go @@ -386,7 +386,7 @@ func (c callName) String() string { for { tool := c.prg.ToolSet[currentCall.ToolID] - name := tool.Parameters.Name + name := tool.Name if name == "" { name = tool.Source.Location } diff --git a/pkg/parser/parser.go b/pkg/parser/parser.go index e1b0b9fa..b00b1506 100644 --- a/pkg/parser/parser.go +++ b/pkg/parser/parser.go @@ -53,8 +53,8 @@ func csv(line string) (result []string) { } func addArg(line string, tool *types.Tool) error { - if tool.Parameters.Arguments == nil { - tool.Parameters.Arguments = &openapi3.Schema{ + if tool.Arguments == nil { + tool.Arguments = &openapi3.Schema{ Type: &openapi3.Types{"object"}, Properties: openapi3.Schemas{}, } @@ -65,7 +65,7 @@ func addArg(line string, tool *types.Tool) error { return fmt.Errorf("invalid arg format: %s", line) } - tool.Parameters.Arguments.Properties[key] = &openapi3.SchemaRef{ + tool.Arguments.Properties[key] = &openapi3.SchemaRef{ Value: &openapi3.Schema{ Description: strings.TrimSpace(value), Type: &openapi3.Types{"string"}, @@ -83,53 +83,53 @@ func isParam(line string, tool *types.Tool, scan *simplescanner) (_ bool, err er value = strings.TrimSpace(value) switch normalize(key) { case "name": - tool.Parameters.Name = value + tool.Name = value case "modelprovider": - tool.Parameters.ModelProvider = true + tool.ModelProvider = true case "model", "modelname": - tool.Parameters.ModelName = value + tool.ModelName = value case "globalmodel", "globalmodelname": - tool.Parameters.GlobalModelName = value + tool.GlobalModelName = value case "description": - tool.Parameters.Description = scan.AddMultiline(value) + tool.Description = scan.AddMultiline(value) case "internalprompt": v, err := toBool(value) if err != nil { return false, err } - tool.Parameters.InternalPrompt = &v + tool.InternalPrompt = &v case "chat": v, err := toBool(value) if err != nil { return false, err } - tool.Parameters.Chat = v + tool.Chat = v case "export", "exporttool", "exports", "exporttools", "sharetool", "sharetools", "sharedtool", "sharedtools": - tool.Parameters.Export = append(tool.Parameters.Export, csv(scan.AddMultiline(value))...) + tool.Export = append(tool.Export, csv(scan.AddMultiline(value))...) case "tool", "tools": - tool.Parameters.Tools = append(tool.Parameters.Tools, csv(scan.AddMultiline(value))...) + tool.Tools = append(tool.Tools, csv(scan.AddMultiline(value))...) case "inputfilter", "inputfilters": - tool.Parameters.InputFilters = append(tool.Parameters.InputFilters, csv(scan.AddMultiline(value))...) + tool.InputFilters = append(tool.InputFilters, csv(scan.AddMultiline(value))...) case "shareinputfilter", "shareinputfilters", "sharedinputfilter", "sharedinputfilters": - tool.Parameters.ExportInputFilters = append(tool.Parameters.ExportInputFilters, csv(scan.AddMultiline(value))...) + tool.ExportInputFilters = append(tool.ExportInputFilters, csv(scan.AddMultiline(value))...) case "outputfilter", "outputfilters": - tool.Parameters.OutputFilters = append(tool.Parameters.OutputFilters, csv(scan.AddMultiline(value))...) + tool.OutputFilters = append(tool.OutputFilters, csv(scan.AddMultiline(value))...) case "shareoutputfilter", "shareoutputfilters", "sharedoutputfilter", "sharedoutputfilters": - tool.Parameters.ExportOutputFilters = append(tool.Parameters.ExportOutputFilters, csv(scan.AddMultiline(value))...) + tool.ExportOutputFilters = append(tool.ExportOutputFilters, csv(scan.AddMultiline(value))...) case "agent", "agents": - tool.Parameters.Agents = append(tool.Parameters.Agents, csv(scan.AddMultiline(value))...) + tool.Agents = append(tool.Agents, csv(scan.AddMultiline(value))...) case "globaltool", "globaltools": - tool.Parameters.GlobalTools = append(tool.Parameters.GlobalTools, csv(scan.AddMultiline(value))...) + tool.GlobalTools = append(tool.GlobalTools, csv(scan.AddMultiline(value))...) case "exportcontext", "exportcontexts", "sharecontext", "sharecontexts", "sharedcontext", "sharedcontexts": - tool.Parameters.ExportContext = append(tool.Parameters.ExportContext, csv(scan.AddMultiline(value))...) + tool.ExportContext = append(tool.ExportContext, csv(scan.AddMultiline(value))...) case "context": - tool.Parameters.Context = append(tool.Parameters.Context, csv(scan.AddMultiline(value))...) + tool.Context = append(tool.Context, csv(scan.AddMultiline(value))...) case "stdin": b, err := toBool(value) if err != nil { return false, err } - tool.Parameters.Stdin = b + tool.Stdin = b case "metadata": mkey, mvalue, _ := strings.Cut(scan.AddMultiline(value), ":") if tool.MetaData == nil { @@ -141,7 +141,7 @@ func isParam(line string, tool *types.Tool, scan *simplescanner) (_ bool, err er return false, err } case "maxtoken", "maxtokens": - tool.Parameters.MaxTokens, err = strconv.Atoi(value) + tool.MaxTokens, err = strconv.Atoi(value) if err != nil { return false, err } @@ -150,21 +150,21 @@ func isParam(line string, tool *types.Tool, scan *simplescanner) (_ bool, err er if err != nil { return false, err } - tool.Parameters.Cache = &b + tool.Cache = &b case "jsonmode", "json", "jsonoutput", "jsonformat", "jsonresponse": - tool.Parameters.JSONResponse, err = toBool(value) + tool.JSONResponse, err = toBool(value) if err != nil { return false, err } case "temperature": - tool.Parameters.Temperature, err = toFloatPtr(value) + tool.Temperature, err = toFloatPtr(value) if err != nil { return false, err } case "credentials", "creds", "credential", "cred": - tool.Parameters.Credentials = append(tool.Parameters.Credentials, csv(scan.AddMultiline(value))...) + tool.Credentials = append(tool.Credentials, csv(scan.AddMultiline(value))...) case "sharecredentials", "sharecreds", "sharecredential", "sharecred", "sharedcredentials", "sharedcreds", "sharedcredential", "sharedcred": - tool.Parameters.ExportCredentials = append(tool.Parameters.ExportCredentials, scan.AddMultiline(value)) + tool.ExportCredentials = append(tool.ExportCredentials, scan.AddMultiline(value)) case "type": tool.Type = types.ToolType(strings.ToLower(value)) default: @@ -211,7 +211,7 @@ type context struct { func (c *context) finish(tools *[]Node) { c.tool.Instructions = strings.TrimSpace(strings.Join(c.instructions, "")) if c.tool.Instructions != "" || - c.tool.Parameters.Name != "" || + c.tool.Name != "" || len(c.tool.Export) > 0 || len(c.tool.Tools) > 0 || c.tool.GlobalModelName != "" || diff --git a/pkg/sdkserver/run.go b/pkg/sdkserver/run.go index 94bdf93c..fda4a215 100644 --- a/pkg/sdkserver/run.go +++ b/pkg/sdkserver/run.go @@ -131,7 +131,7 @@ func writeError(logger mvl.Logger, w http.ResponseWriter, code int, err error) { b, err := json.Marshal(resp) if err != nil { - _, _ = w.Write([]byte(fmt.Sprintf(`{"stderr": "%s"}`, err.Error()))) + _, _ = fmt.Fprintf(w, `{"stderr": "%s"}`, err.Error()) return } @@ -148,7 +148,7 @@ func writeServerSentEvent(logger mvl.Logger, w http.ResponseWriter, event any) { return } - _, err = w.Write([]byte(fmt.Sprintf("data: %s\n\n", ev))) + _, err = fmt.Fprintf(w, "data: %s\n\n", ev) if err == nil { if f, ok := w.(http.Flusher); ok { f.Flush() diff --git a/pkg/sdkserver/server.go b/pkg/sdkserver/server.go index 41066d30..f15cc68f 100644 --- a/pkg/sdkserver/server.go +++ b/pkg/sdkserver/server.go @@ -92,7 +92,7 @@ func run(ctx context.Context, listener net.Listener, opts Options) error { } events := broadcaster.New[event]() - opts.Options.Runner.MonitorFactory = NewSessionFactory(events) + opts.Runner.MonitorFactory = NewSessionFactory(events) go events.Start(ctx) token := uuid.NewString() @@ -115,7 +115,7 @@ func run(ctx context.Context, listener net.Listener, opts Options) error { client: g, events: events, - runtimeManager: runtimes.Default(opts.Options.Cache.CacheDir, opts.SystemToolsDir), + runtimeManager: runtimes.Default(opts.Cache.CacheDir, opts.SystemToolsDir), waitingToConfirm: make(map[string]chan runner.AuthorizerResponse), waitingToPrompt: make(map[string]chan map[string]string), running: make(map[string]chan struct{}), diff --git a/pkg/types/tool.go b/pkg/types/tool.go index 0c8bd77c..54780278 100644 --- a/pkg/types/tool.go +++ b/pkg/types/tool.go @@ -398,94 +398,94 @@ func (t ToolDef) String() string { func (t ToolDef) Print() string { buf := &strings.Builder{} - if t.Parameters.GlobalModelName != "" { - _, _ = fmt.Fprintf(buf, "Global Model Name: %s\n", t.Parameters.GlobalModelName) + if t.GlobalModelName != "" { + _, _ = fmt.Fprintf(buf, "Global Model Name: %s\n", t.GlobalModelName) } - if len(t.Parameters.GlobalTools) != 0 { - _, _ = fmt.Fprintf(buf, "Global Tools: %s\n", strings.Join(t.Parameters.GlobalTools, ", ")) + if len(t.GlobalTools) != 0 { + _, _ = fmt.Fprintf(buf, "Global Tools: %s\n", strings.Join(t.GlobalTools, ", ")) } - if t.Parameters.Name != "" { - _, _ = fmt.Fprintf(buf, "Name: %s\n", t.Parameters.Name) + if t.Name != "" { + _, _ = fmt.Fprintf(buf, "Name: %s\n", t.Name) } - if t.Parameters.Description != "" { - _, _ = fmt.Fprintf(buf, "Description: %s\n", t.Parameters.Description) + if t.Description != "" { + _, _ = fmt.Fprintf(buf, "Description: %s\n", t.Description) } - if t.Parameters.Type != ToolTypeDefault { + if t.Type != ToolTypeDefault { _, _ = fmt.Fprintf(buf, "Type: %s\n", strings.ToUpper(string(t.Type[0]))+string(t.Type[1:])) } - if len(t.Parameters.Agents) != 0 { - _, _ = fmt.Fprintf(buf, "Agents: %s\n", strings.Join(t.Parameters.Agents, ", ")) + if len(t.Agents) != 0 { + _, _ = fmt.Fprintf(buf, "Agents: %s\n", strings.Join(t.Agents, ", ")) } - if len(t.Parameters.Tools) != 0 { - _, _ = fmt.Fprintf(buf, "Tools: %s\n", strings.Join(t.Parameters.Tools, ", ")) + if len(t.Tools) != 0 { + _, _ = fmt.Fprintf(buf, "Tools: %s\n", strings.Join(t.Tools, ", ")) } - if len(t.Parameters.Export) != 0 { - _, _ = fmt.Fprintf(buf, "Share Tools: %s\n", strings.Join(t.Parameters.Export, ", ")) + if len(t.Export) != 0 { + _, _ = fmt.Fprintf(buf, "Share Tools: %s\n", strings.Join(t.Export, ", ")) } - if len(t.Parameters.Context) != 0 { - _, _ = fmt.Fprintf(buf, "Context: %s\n", strings.Join(t.Parameters.Context, ", ")) + if len(t.Context) != 0 { + _, _ = fmt.Fprintf(buf, "Context: %s\n", strings.Join(t.Context, ", ")) } - if len(t.Parameters.ExportContext) != 0 { - _, _ = fmt.Fprintf(buf, "Share Context: %s\n", strings.Join(t.Parameters.ExportContext, ", ")) + if len(t.ExportContext) != 0 { + _, _ = fmt.Fprintf(buf, "Share Context: %s\n", strings.Join(t.ExportContext, ", ")) } - if len(t.Parameters.InputFilters) != 0 { - _, _ = fmt.Fprintf(buf, "Input Filters: %s\n", strings.Join(t.Parameters.InputFilters, ", ")) + if len(t.InputFilters) != 0 { + _, _ = fmt.Fprintf(buf, "Input Filters: %s\n", strings.Join(t.InputFilters, ", ")) } - if len(t.Parameters.ExportInputFilters) != 0 { - _, _ = fmt.Fprintf(buf, "Share Input Filters: %s\n", strings.Join(t.Parameters.ExportInputFilters, ", ")) + if len(t.ExportInputFilters) != 0 { + _, _ = fmt.Fprintf(buf, "Share Input Filters: %s\n", strings.Join(t.ExportInputFilters, ", ")) } - if len(t.Parameters.OutputFilters) != 0 { - _, _ = fmt.Fprintf(buf, "Output Filters: %s\n", strings.Join(t.Parameters.OutputFilters, ", ")) + if len(t.OutputFilters) != 0 { + _, _ = fmt.Fprintf(buf, "Output Filters: %s\n", strings.Join(t.OutputFilters, ", ")) } - if len(t.Parameters.ExportOutputFilters) != 0 { - _, _ = fmt.Fprintf(buf, "Share Output Filters: %s\n", strings.Join(t.Parameters.ExportOutputFilters, ", ")) + if len(t.ExportOutputFilters) != 0 { + _, _ = fmt.Fprintf(buf, "Share Output Filters: %s\n", strings.Join(t.ExportOutputFilters, ", ")) } - if t.Parameters.MaxTokens != 0 { - _, _ = fmt.Fprintf(buf, "Max Tokens: %d\n", t.Parameters.MaxTokens) + if t.MaxTokens != 0 { + _, _ = fmt.Fprintf(buf, "Max Tokens: %d\n", t.MaxTokens) } - if t.Parameters.ModelName != "" { - _, _ = fmt.Fprintf(buf, "Model: %s\n", t.Parameters.ModelName) + if t.ModelName != "" { + _, _ = fmt.Fprintf(buf, "Model: %s\n", t.ModelName) } - if t.Parameters.ModelProvider { + if t.ModelProvider { _, _ = fmt.Fprintf(buf, "Model Provider: true\n") } - if t.Parameters.JSONResponse { + if t.JSONResponse { _, _ = fmt.Fprintln(buf, "JSON Response: true") } - if t.Parameters.Cache != nil && !*t.Parameters.Cache { + if t.Cache != nil && !*t.Cache { _, _ = fmt.Fprintln(buf, "Cache: false") } - if t.Parameters.Stdin { + if t.Stdin { _, _ = fmt.Fprintln(buf, "Stdin: true") } - if t.Parameters.Temperature != nil { - _, _ = fmt.Fprintf(buf, "Temperature: %f\n", *t.Parameters.Temperature) + if t.Temperature != nil { + _, _ = fmt.Fprintf(buf, "Temperature: %f\n", *t.Temperature) } - if t.Parameters.Arguments != nil { + if t.Arguments != nil { var keys []string - for k := range t.Parameters.Arguments.Properties { + for k := range t.Arguments.Properties { keys = append(keys, k) } sort.Strings(keys) for _, key := range keys { - prop := t.Parameters.Arguments.Properties[key] + prop := t.Arguments.Properties[key] _, _ = fmt.Fprintf(buf, "Parameter: %s: %s\n", key, prop.Value.Description) } } - if t.Parameters.InternalPrompt != nil { - _, _ = fmt.Fprintf(buf, "Internal Prompt: %v\n", *t.Parameters.InternalPrompt) + if t.InternalPrompt != nil { + _, _ = fmt.Fprintf(buf, "Internal Prompt: %v\n", *t.InternalPrompt) } - if len(t.Parameters.Credentials) > 0 { - for _, cred := range t.Parameters.Credentials { + if len(t.Credentials) > 0 { + for _, cred := range t.Credentials { _, _ = fmt.Fprintf(buf, "Credential: %s\n", cred) } } - if len(t.Parameters.ExportCredentials) > 0 { - for _, exportCred := range t.Parameters.ExportCredentials { + if len(t.ExportCredentials) > 0 { + for _, exportCred := range t.ExportCredentials { _, _ = fmt.Fprintf(buf, "Share Credential: %s\n", exportCred) } } - if t.Parameters.Chat { + if t.Chat { _, _ = fmt.Fprintf(buf, "Chat: true\n") } @@ -618,10 +618,11 @@ func (t Tool) getAgents(prg *Program) (result []ToolReference, _ error) { } func (t Tool) GetToolsByType(prg *Program, toolType ToolType) ([]ToolReference, error) { - if toolType == ToolTypeAgent { + switch toolType { + case ToolTypeAgent: // Agents are special, they can only be sourced from direct references and not the generic 'tool:' or shared by references return t.getAgents(prg) - } else if toolType == ToolTypeCredential { + case ToolTypeCredential: // Credentials are special too, you can only get shared credentials from directly referenced credentials return t.getCredentials(prg) } @@ -784,7 +785,7 @@ func toolRefsToCompletionTools(completionTools []ToolReference, prg Program) (re subToolName = subToolRef.Named } - args := subTool.Parameters.Arguments + args := subTool.Arguments if args == nil && !subTool.IsCommand() && !subTool.Chat { args = &system.DefaultToolSchema } else if args == nil && !subTool.IsCommand() { @@ -798,7 +799,7 @@ func toolRefsToCompletionTools(completionTools []ToolReference, prg Program) (re Function: CompletionFunctionDefinition{ ToolID: subTool.ID, Name: PickToolName(subToolName, toolNames), - Description: subTool.Parameters.Description, + Description: subTool.Description, Parameters: args, }, }) diff --git a/pkg/types/toolstring.go b/pkg/types/toolstring.go index 086ad043..b5e0d1d5 100644 --- a/pkg/types/toolstring.go +++ b/pkg/types/toolstring.go @@ -50,9 +50,8 @@ func ToSysDisplayString(id string, args map[string]string) (string, error) { case "sys.download": if location := args["location"]; location != "" { return fmt.Sprintf("Downloading `%s` to `%s`", args["url"], location), nil - } else { - return fmt.Sprintf("Downloading `%s` to workspace", args["url"]), nil } + return fmt.Sprintf("Downloading `%s` to workspace", args["url"]), nil case "sys.exec": return fmt.Sprintf("Running `%s`", args["command"]), nil case "sys.find": diff --git a/static/fs.go b/static/fs.go index 88e5f4ec..aff200c1 100644 --- a/static/fs.go +++ b/static/fs.go @@ -1,9 +1,6 @@ package static -import ( - "embed" - _ "embed" -) +import "embed" //go:embed * ui/_nuxt/* var UI embed.FS diff --git a/tools/gendocs/main.go b/tools/gendocs/main.go index f931bbea..362ea17b 100644 --- a/tools/gendocs/main.go +++ b/tools/gendocs/main.go @@ -40,7 +40,7 @@ func main() { func filePrepender(filename string) string { name := filepath.Base(filename) base := strings.TrimSuffix(name, path.Ext(name)) - return fmt.Sprintf(fmTemplate, strings.Replace(base, "_", " ", -1)) + return fmt.Sprintf(fmTemplate, strings.ReplaceAll(base, "_", " ")) } func linkHandler(name string) string {