Merge pull request #17 from thedadams/first-rewrite

feat: add Run type for more manageable implementation

Author: thedadams

.gitignore

@@ -24,5 +24,6 @@ go.work
 .idea/
 .vscode/
 
+workspace/
 bin/
 workspace/

README.md

@@ -16,6 +16,14 @@ To use the module, you need to first set the OPENAI_API_KEY environment variable
 
 Additionally, you need the `gptscript` binary. You can install it on your system using the [installation instructions](https://github.com/gptscript-ai/gptscript?tab=readme-ov-file#1-install-the-latest-release). The binary can be on the PATH, or the `GPTSCRIPT_BIN` environment variable can be used to specify its location.
 
+## Client
+
+There are currently a couple "global" options, and the client helps to manage those. A client without any options is
+likely what you want. However, here are the current global options:
+
+- `gptscriptURL`: The URL (including `http(s)://) of an "SDK server" to use instead of the fork/exec model.
+- `gptscriptBin`: The path to a `gptscript` binary to use instead of the bundled one.
+
 ## Options
 
 These are optional options that can be passed to the various `exec` functions.
@@ -26,6 +34,10 @@ None of the options is required, and the defaults will reduce the number of call
 - `quiet`: No output logging
 - `chdir`: Change current working directory
 - `subTool`: Use tool of this name, not the first tool
+- `input`: Input arguments for the tool run
+- `workspace`: Directory to use for the workspace, if specified it will not be deleted on exit
+- `inlcudeEvents`: Whether to include the streaming of events. Default (false). Note that if this is true, you must stream the events. See below for details.
+- `chatState`: The chat state to continue, or null to start a new chat and return the state
 
 ## Functions
 
@@ -45,7 +57,9 @@ import (
 )
 
 func listTools(ctx context.Context) (string, error) {
-	return gogptscript.ListTools(ctx)
+	client := &gogptscript.Client{}
+	client.Complete()
+	return client.ListTools(ctx)
 }
 ```
 
@@ -65,13 +79,15 @@ import (
 )
 
 func listModels(ctx context.Context) ([]string, error) {
-	return gogptscript.ListModels(ctx)
+	client := &gogptscript.Client{}
+	client.Complete()
+	return client.ListModels(ctx)
 }
 ```
 
-### ExecTool
+### Parse
 
-Executes a prompt with optional arguments.
+Parse file into a Tool data structure
 
 ```go
 package main
@@ -82,18 +98,17 @@ import (
 	gogptscript "github.com/gptscript-ai/go-gptscript"
 )
 
-func runTool(ctx context.Context) (string, error) {
-	t := gogptscript.Tool{
-		Instructions: "who was the president of the united states in 1928?",
-	}
-
-	return gogptscript.ExecTool(ctx, gogptscript.Opts{}, t)
+func parse(ctx context.Context, fileName string) ([]gogptscript.Node, error) {
+	client := &gogptscript.Client{}
+	client.Complete()
+	
+	return client.Parse(ctx, fileName)
 }
 ```
 
-### ExecFile
+### ParseTool
 
-Executes a GPT script file with optional input and arguments. The script is relative to the callers source directory.
+Parse contents that represents a GPTScript file into a data structure.
 
 ```go
 package main
@@ -104,18 +119,17 @@ import (
 	gogptscript "github.com/gptscript-ai/go-gptscript"
 )
 
-func execFile(ctx context.Context) (string, error) {
-	opts := gogptscript.Opts{
-		DisableCache: &[]bool{true}[0],
-	}
-
-	return gogptscript.ExecFile(ctx, "./hello.gpt", "--input World", opts)
+func parseTool(ctx context.Context, contents string) ([]gogptscript.Node, error) {
+	client := &gogptscript.Client{}
+	client.Complete()
+	
+	return client.ParseTool(ctx, contents)
 }
 ```
 
-### StreamExecTool
+### Fmt
 
-Executes a gptscript with optional input and arguments, and returns the output streams.
+Parse convert a tool data structure into a GPTScript file.
 
 ```go
 package main
@@ -126,22 +140,17 @@ import (
 	gogptscript "github.com/gptscript-ai/go-gptscript"
 )
 
-func streamExecTool(ctx context.Context) error {
-	t := gogptscript.Tool{
-		Instructions: "who was the president of the united states in 1928?",
-	}
-
-	stdOut, stdErr, wait := gogptscript.StreamExecTool(ctx, gogptscript.Opts{}, t)
-
-	// Read from stdOut and stdErr before call wait()
-
-	return wait()
+func parse(ctx context.Context, nodes []gogptscript.node) (string, error) {
+	client := &gogptscript.Client{}
+	client.Complete()
+	
+	return client.Fmt(ctx, nodes)
 }
 ```
 
-### StreamExecToolWithEvents
+### Evaluate
 
-Executes a gptscript with optional input and arguments, and returns the stdout, stderr, and gptscript events streams.
+Executes a tool with optional arguments.
 
 ```go
 package main
@@ -152,22 +161,26 @@ import (
 	gogptscript "github.com/gptscript-ai/go-gptscript"
 )
 
-func streamExecTool(ctx context.Context) error {
-	t := gogptscript.Tool{
+func runTool(ctx context.Context) (string, error) {
+	t := gogptscript.ToolDef{
 		Instructions: "who was the president of the united states in 1928?",
 	}
 
-	stdOut, stdErr, events, wait := gogptscript.StreamExecToolWithEvents(ctx, gogptscript.Opts{}, t)
+	client := &gogptscript.Client{}
+	client.Complete()
 
-	// Read from stdOut and stdErr before call wait()
+	run, err := client.Evaluate(ctx, gogptscript.Opts{}, t)
+	if err != nil {
+		return "", err
+	}
 
-	return wait()
+	return run.Text()
 }
 ```
 
-### streamExecFile
+### Run
 
-The script is relative to the callers source directory.
+Executes a GPT script file with optional input and arguments. The script is relative to the callers source directory.
 
 ```go
 package main
@@ -178,22 +191,27 @@ import (
 	gogptscript "github.com/gptscript-ai/go-gptscript"
 )
 
-func streamExecTool(ctx context.Context) error {
+func runFile(ctx context.Context) (string, error) {
 	opts := gogptscript.Opts{
 		DisableCache: &[]bool{true}[0],
+		Input: "--input hello",
 	}
 
-	stdOut, stdErr, wait := gogptscript.StreamExecFile(ctx, "./hello.gpt", "--input world", opts)
+	client := &gogptscript.Client{}
+	client.Complete()
 
-	// Read from stdOut and stdErr before call wait()
+	run, err := client.Run(ctx, "./hello.gpt",  opts)
+	if err != nil {
+		return "", err
+	}
 
-	return wait()
+	return run.Text()
 }
 ```
 
-### streamExecFileWithEvents
+### Streaming events
 
-The script is relative to the callers source directory.
+In order to stream events, you must set `IncludeEvents` option to `true`. You if you don't set this and try to stream events, then it will succeed, but you will not get any events. More importantly, if you set `IncludeEvents` to `true`, you must stream the events for the script to complete.
 
 ```go
 package main
@@ -206,14 +224,26 @@ import (
 
 func streamExecTool(ctx context.Context) error {
 	opts := gogptscript.Opts{
-		DisableCache: &[]bool{true}[0],
+		DisableCache:  &[]bool{true}[0],
+		IncludeEvents: true,
+		Input:         "--input world",
 	}
 
-	stdOut, stdErr, events, wait := gogptscript.StreamExecFileWithEvents(ctx, "./hello.gpt", "--input world", opts)
+	client := &gogptscript.Client{}
+	client.Complete()
 
-	// Read from stdOut and stdErr before call wait()
+	run, err := client.Run(ctx, "./hello.gpt", opts)
+	if err != nil {
+		return err
+	}
 
-	return wait()
+	for event := range run.Events() {
+		// Process event...
+	}
+
+	// Wait for the output to ensure the script completes successfully.
+	_, err = run.Text()
+	return err
 }
 ```
 
@@ -235,12 +265,6 @@ func streamExecTool(ctx context.Context) error {
 | instructions      | string         | `""`        | Instructions on how to use the tool.                                                          |
 | jsonResponse      | boolean        | `false`     | Whether the tool returns a JSON response instead of plain text. You must include the word 'json' in the body of the prompt                               |
 
-### FreeForm Parameters
-
-| Argument  | Type   | Default | Description                           |
-|-----------|--------|---------|---------------------------------------|
-| content   | string | `""`    | This is a multi-line string that contains the  entire contents of a valid gptscript file|
-
 ## License
 
 Copyright (c) 2024, [Acorn Labs, Inc.](https://www.acorn.io)

client.go

@@ -0,0 +1,209 @@
+package gptscript
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const relativeToBinaryPath = "<me>"
+
+type Client struct {
+	GPTScriptURL string
+	GPTScriptBin string
+}
+
+func (c *Client) Complete() {
+	if c.GPTScriptBin == "" {
+		c.GPTScriptBin = getCommand()
+	}
+}
+
+func (c *Client) Evaluate(ctx context.Context, opts Opts, tools ...fmt.Stringer) (*Run, error) {
+	return (&Run{
+		url:         c.GPTScriptURL,
+		binPath:     c.GPTScriptBin,
+		requestPath: "evaluate",
+		state:       Creating,
+		opts:        opts,
+		content:     concatTools(tools),
+		chatState:   opts.ChatState,
+	}).NextChat(ctx, opts.Input)
+}
+
+func (c *Client) Run(ctx context.Context, toolPath string, opts Opts) (*Run, error) {
+	return (&Run{
+		url:         c.GPTScriptURL,
+		binPath:     c.GPTScriptBin,
+		requestPath: "run",
+		state:       Creating,
+		opts:        opts,
+		toolPath:    toolPath,
+		chatState:   opts.ChatState,
+	}).NextChat(ctx, opts.Input)
+}
+
+// Parse will parse the given file into an array of Nodes.
+func (c *Client) Parse(ctx context.Context, fileName string) ([]Node, error) {
+	out, err := c.runBasicCommand(ctx, "parse", "parse", fileName, "")
+	if err != nil {
+		return nil, err
+	}
+
+	var doc Document
+	if err = json.Unmarshal([]byte(out), &doc); err != nil {
+		return nil, err
+	}
+
+	return doc.Nodes, nil
+}
+
+// ParseTool will parse the given string into a tool.
+func (c *Client) ParseTool(ctx context.Context, toolDef string) ([]Node, error) {
+	out, err := c.runBasicCommand(ctx, "parse", "parse", "", toolDef)
+	if err != nil {
+		return nil, err
+	}
+
+	var doc Document
+	if err = json.Unmarshal([]byte(out), &doc); err != nil {
+		return nil, err
+	}
+
+	return doc.Nodes, nil
+}
+
+// Fmt will format the given nodes into a string.
+func (c *Client) Fmt(ctx context.Context, nodes []Node) (string, error) {
+	b, err := json.Marshal(Document{Nodes: nodes})
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal nodes: %w", err)
+	}
+
+	run := &runSubCommand{
+		Run: Run{
+			url:         c.GPTScriptURL,
+			binPath:     c.GPTScriptBin,
+			requestPath: "fmt",
+			state:       Creating,
+			toolPath:    "",
+			content:     string(b),
+		},
+	}
+
+	if run.url != "" {
+		err = run.request(ctx, Document{Nodes: nodes})
+	} else {
+		err = run.exec(ctx, "fmt")
+	}
+	if err != nil {
+		return "", err
+	}
+
+	out, err := run.Text()
+	if err != nil {
+		return "", err
+	}
+	if run.err != nil {
+		return run.ErrorOutput(), run.err
+	}
+
+	return out, nil
+}
+
+// Version will return the output of `gptscript --version`
+func (c *Client) Version(ctx context.Context) (string, error) {
+	out, err := c.runBasicCommand(ctx, "--version", "version", "", "")
+	if err != nil {
+		return "", err
+	}
+
+	return out, nil
+}
+
+// ListTools will list all the available tools.
+func (c *Client) ListTools(ctx context.Context) (string, error) {
+	out, err := c.runBasicCommand(ctx, "--list-tools", "list-tools", "", "")
+	if err != nil {
+		return "", err
+	}
+
+	return out, nil
+}
+
+// ListModels will list all the available models.
+func (c *Client) ListModels(ctx context.Context) ([]string, error) {
+	out, err := c.runBasicCommand(ctx, "--list-models", "list-models", "", "")
+	if err != nil {
+		return nil, err
+	}
+
+	return strings.Split(strings.TrimSpace(out), "\n"), nil
+}
+
+func (c *Client) runBasicCommand(ctx context.Context, command, requestPath, toolPath, content string) (string, error) {
+	run := &runSubCommand{
+		Run: Run{
+			url:         c.GPTScriptURL,
+			binPath:     c.GPTScriptBin,
+			requestPath: requestPath,
+			state:       Creating,
+			toolPath:    toolPath,
+			content:     content,
+		},
+	}
+
+	var err error
+	if run.url != "" {
+		var m any
+		if content != "" || toolPath != "" {
+			m = map[string]any{"input": content, "file": toolPath}
+		}
+		err = run.request(ctx, m)
+	} else {
+		err = run.exec(ctx, command)
+	}
+	if err != nil {
+		return "", err
+	}
+
+	out, err := run.Text()
+	if err != nil {
+		return "", err
+	}
+	if run.err != nil {
+		return run.ErrorOutput(), run.err
+	}
+
+	return out, nil
+}
+
+func getCommand() string {
+	if gptScriptBin := os.Getenv("GPTSCRIPT_BIN"); gptScriptBin != "" {
+		if len(os.Args) == 0 {
+			return gptScriptBin
+		}
+		return determineProperCommand(filepath.Dir(os.Args[0]), gptScriptBin)
+	}
+
+	return "gptscript"
+}
+
+// determineProperCommand is for testing purposes. Users should use getCommand instead.
+func determineProperCommand(dir, bin string) string {
+	if !strings.HasPrefix(bin, relativeToBinaryPath) {
+		return bin
+	}
+
+	bin = filepath.Join(dir, strings.TrimPrefix(bin, relativeToBinaryPath))
+	if !filepath.IsAbs(bin) {
+		bin = "." + string(os.PathSeparator) + bin
+	}
+
+	slog.Debug("Using gptscript binary: " + bin)
+	return bin
+}

client_test.go

@@ -0,0 +1,67 @@
+package gptscript
+
+import "time"
+
+type Event struct {
+	RunID              string          `json:"runID,omitempty"`
+	Time               time.Time       `json:"time,omitempty"`
+	CallContext        *CallContext    `json:"callContext,omitempty"`
+	ToolSubCalls       map[string]Call `json:"toolSubCalls,omitempty"`
+	ToolResults        int             `json:"toolResults,omitempty"`
+	Type               EventType       `json:"type,omitempty"`
+	ChatCompletionID   string          `json:"chatCompletionId,omitempty"`
+	ChatRequest        any             `json:"chatRequest,omitempty"`
+	ChatResponse       any             `json:"chatResponse,omitempty"`
+	ChatResponseCached bool            `json:"chatResponseCached,omitempty"`
+	Content            string          `json:"content,omitempty"`
+	Program            *Program        `json:"program,omitempty"`
+	Input              string          `json:"input,omitempty"`
+	Output             string          `json:"output,omitempty"`
+	Err                string          `json:"err,omitempty"`
+}
+
+type Program struct {
+	Name        string  `json:"name,omitempty"`
+	EntryToolID string  `json:"entryToolId,omitempty"`
+	ToolSet     ToolSet `json:"toolSet,omitempty"`
+}
+
+type ToolSet map[string]Tool
+
+type Call struct {
+	ToolID string `json:"toolID,omitempty"`
+	Input  string `json:"input,omitempty"`
+}
+
+type CallContext struct {
+	ID           string         `json:"id"`
+	Tool         Tool           `json:"tool"`
+	InputContext []InputContext `json:"inputContext"`
+	ToolCategory ToolCategory   `json:"toolCategory,omitempty"`
+	ToolName     string         `json:"toolName,omitempty"`
+	ParentID     string         `json:"parentID,omitempty"`
+}
+
+type InputContext struct {
+	ToolID  string `json:"toolID,omitempty"`
+	Content string `json:"content,omitempty"`
+}
+
+type ToolCategory string
+
+const (
+	CredentialToolCategory ToolCategory = "credential"
+	ContextToolCategory    ToolCategory = "context"
+	NoCategory             ToolCategory = ""
+)
+
+type EventType string
+
+const (
+	EventTypeCallStart    EventType = "callStart"
+	EventTypeCallContinue EventType = "callContinue"
+	EventTypeCallSubCalls EventType = "callSubCalls"
+	EventTypeCallProgress EventType = "callProgress"
+	EventTypeChat         EventType = "callChat"
+	EventTypeCallFinish   EventType = "callFinish"
+)

event.go

@@ -10,5 +10,5 @@ import (
 
 func appendExtraFiles(cmd *exec.Cmd, extraFiles ...*os.File) {
 	cmd.ExtraFiles = append(cmd.ExtraFiles, extraFiles...)
-	cmd.Args = append(cmd.Args[:1], append([]string{"--events-stream-to", fmt.Sprintf("fd://%d", len(cmd.ExtraFiles)+2)}, cmd.Args[1:]...)...)
+	cmd.Args = append(cmd.Args[:1], append([]string{fmt.Sprintf("--events-stream-to=fd://%d", len(cmd.ExtraFiles)+2)}, cmd.Args[1:]...)...)
 }

exec.go

@@ -0,0 +1,38 @@
+package gptscript
+
+import (
+	"fmt"
+)
+
+// Opts represents options for the gptscript tool or file.
+type Opts struct {
+	Input         string `json:"input"`
+	DisableCache  bool   `json:"disableCache"`
+	CacheDir      string `json:"cacheDir"`
+	Quiet         bool   `json:"quiet"`
+	Chdir         string `json:"chdir"`
+	SubTool       string `json:"subTool"`
+	Workspace     string `json:"workspace"`
+	ChatState     string `json:"chatState"`
+	IncludeEvents bool   `json:"includeEvents"`
+}
+
+func (o Opts) toArgs() []string {
+	var args []string
+	if o.DisableCache {
+		args = append(args, "--disable-cache")
+	}
+	if o.CacheDir != "" {
+		args = append(args, "--cache-dir="+o.CacheDir)
+	}
+	if o.Chdir != "" {
+		args = append(args, "--chdir="+o.Chdir)
+	}
+	if o.SubTool != "" {
+		args = append(args, "--sub-tool="+o.SubTool)
+	}
+	if o.Workspace != "" {
+		args = append(args, "--workspace="+o.Workspace)
+	}
+	return append(args, "--quiet="+fmt.Sprint(o.Quiet))
+}

exec_test.go

@@ -0,0 +1 @@
+Who wrote Catcher in the Rye?

exec_unix.go

@@ -0,0 +1,4 @@
+chat: true
+tools: sys.chat.finish
+
+You are a chat bot. Don't finish the conversation until I say 'bye'.

opts.go

@@ -7,40 +7,31 @@ import (
 	"github.com/getkin/kin-openapi/openapi3"
 )
 
-// SimpleTool struct represents a tool with various configurations.
-type SimpleTool struct {
-	Name           string
-	Description    string
-	Tools          []string
-	MaxTokens      *int // Using a pointer to represent optional int
-	Model          string
-	Cache          bool
-	Temperature    *float64 // Using a pointer to represent optional float64
-	Args           map[string]string
-	InternalPrompt bool
-	Instructions   string
-	JSONResponse   bool
+// ToolDef struct represents a tool with various configurations.
+type ToolDef struct {
+	Name            string            `json:"name,omitempty"`
+	Description     string            `json:"description,omitempty"`
+	MaxTokens       int               `json:"maxTokens,omitempty"`
+	ModelName       string            `json:"modelName,omitempty"`
+	ModelProvider   bool              `json:"modelProvider,omitempty"`
+	JSONResponse    bool              `json:"jsonResponse,omitempty"`
+	Chat            bool              `json:"chat,omitempty"`
+	Temperature     *float32          `json:"temperature,omitempty"`
+	Cache           *bool             `json:"cache,omitempty"`
+	InternalPrompt  *bool             `json:"internalPrompt"`
+	Args            map[string]string `json:"args,omitempty"`
+	Tools           []string          `json:"tools,omitempty"`
+	GlobalTools     []string          `json:"globalTools,omitempty"`
+	GlobalModelName string            `json:"globalModelName,omitempty"`
+	Context         []string          `json:"context,omitempty"`
+	ExportContext   []string          `json:"exportContext,omitempty"`
+	Export          []string          `json:"export,omitempty"`
+	Credentials     []string          `json:"credentials,omitempty"`
+	Instructions    string            `json:"instructions,omitempty"`
 }
 
-// NewSimpleTool is a constructor for SimpleTool struct.
-func NewSimpleTool(name, description string, tools []string, maxTokens *int, model string, cache bool, temperature *float64, args map[string]string, internalPrompt bool, instructions string, jsonResponse bool) *SimpleTool {
-	return &SimpleTool{
-		Name:           name,
-		Description:    description,
-		Tools:          tools,
-		MaxTokens:      maxTokens,
-		Model:          model,
-		Cache:          cache,
-		Temperature:    temperature,
-		Args:           args,
-		InternalPrompt: internalPrompt,
-		Instructions:   instructions,
-		JSONResponse:   jsonResponse,
-	}
-}
-
-// String method returns the string representation of SimpleTool.
-func (t *SimpleTool) String() string {
+// String method returns the string representation of ToolDef.
+func (t *ToolDef) String() string {
 	var sb strings.Builder
 
 	if t.Name != "" {
@@ -52,13 +43,13 @@ func (t *SimpleTool) String() string {
 	if len(t.Tools) > 0 {
 		sb.WriteString(fmt.Sprintf("Tools: %s\n", strings.Join(t.Tools, ", ")))
 	}
-	if t.MaxTokens != nil {
-		sb.WriteString(fmt.Sprintf("Max tokens: %d\n", *t.MaxTokens))
+	if t.MaxTokens != 0 {
+		sb.WriteString(fmt.Sprintf("Max tokens: %d\n", t.MaxTokens))
 	}
-	if t.Model != "" {
-		sb.WriteString(fmt.Sprintf("Model: %s\n", t.Model))
+	if t.ModelName != "" {
+		sb.WriteString(fmt.Sprintf("Model: %s\n", t.ModelName))
 	}
-	if !t.Cache {
+	if t.Cache != nil && !*t.Cache {
 		sb.WriteString("Cache: false\n")
 	}
 	if t.Temperature != nil {
@@ -72,7 +63,10 @@ func (t *SimpleTool) String() string {
 			sb.WriteString(fmt.Sprintf("Args: %s: %s\n", arg, desc))
 		}
 	}
-	if t.InternalPrompt {
+	if t.Chat {
+		sb.WriteString("Chat: true\n")
+	}
+	if t.InternalPrompt != nil && *t.InternalPrompt {
 		sb.WriteString("Internal prompt: true\n")
 	}
 	if t.Instructions != "" {
@@ -82,24 +76,9 @@ func (t *SimpleTool) String() string {
 	return sb.String()
 }
 
-// FreeForm struct represents free-form content.
-type FreeForm struct {
-	Content string
-}
-
-// NewFreeForm is a constructor for FreeForm struct.
-func NewFreeForm(content string) *FreeForm {
-	return &FreeForm{Content: content}
-}
+type ToolDefs []ToolDef
 
-// String method returns the string representation of FreeForm.
-func (f *FreeForm) String() string {
-	return f.Content
-}
-
-type Tools []SimpleTool
-
-func (t Tools) String() string {
+func (t ToolDefs) String() string {
 	resp := make([]string, 0, len(t))
 	for _, tool := range t {
 		resp = append(resp, tool.String())
@@ -125,10 +104,9 @@ type ToolNode struct {
 }
 
 type Tool struct {
-	Parameters   `json:",inline"`
-	Instructions string `json:"instructions,omitempty"`
-
+	ToolDef     `json:",inline"`
 	ID          string            `json:"id,omitempty"`
+	Arguments   *openapi3.Schema  `json:"arguments,omitempty"`
 	ToolMapping map[string]string `json:"toolMapping,omitempty"`
 	LocalTools  map[string]string `json:"localTools,omitempty"`
 	Source      ToolSource        `json:"source,omitempty"`
@@ -149,24 +127,13 @@ type Repo struct {
 	Revision string
 }
 
-type Parameters struct {
-	Name            string           `json:"name,omitempty"`
-	Description     string           `json:"description,omitempty"`
-	MaxTokens       int              `json:"maxTokens,omitempty"`
-	ModelName       string           `json:"modelName,omitempty"`
-	ModelProvider   bool             `json:"modelProvider,omitempty"`
-	JSONResponse    bool             `json:"jsonResponse,omitempty"`
-	Chat            bool             `json:"chat,omitempty"`
-	Temperature     *float32         `json:"temperature,omitempty"`
-	Cache           *bool            `json:"cache,omitempty"`
-	InternalPrompt  *bool            `json:"internalPrompt"`
-	Arguments       *openapi3.Schema `json:"arguments,omitempty"`
-	Tools           []string         `json:"tools,omitempty"`
-	GlobalTools     []string         `json:"globalTools,omitempty"`
-	GlobalModelName string           `json:"globalModelName,omitempty"`
-	Context         []string         `json:"context,omitempty"`
-	ExportContext   []string         `json:"exportContext,omitempty"`
-	Export          []string         `json:"export,omitempty"`
-	Credentials     []string         `json:"credentials,omitempty"`
-	Blocking        bool             `json:"-"`
+func concatTools(tools []fmt.Stringer) string {
+	var sb strings.Builder
+	for i, tool := range tools {
+		sb.WriteString(tool.String())
+		if i < len(tools)-1 {
+			sb.WriteString("\n---\n")
+		}
+	}
+	return sb.String()
 }