interp(text/template): init text/template interpreter

Author: rinor

pkg/builtin/builtin.go

@@ -35,6 +35,7 @@ var SafeTools = map[string]struct{}{
 	"sys.time.now":                  {},
 	"sys.context":                   {},
 	"sys.model.provider.credential": {},
+	"sys.interp.template.text":      {},
 }
 
 var tools = map[string]types.Tool{

pkg/engine/engine.go

@@ -299,7 +299,10 @@ func (e *Engine) Start(ctx Context, input string) (ret *Return, _ error) {
 			return e.runOpenAPI(tool, input)
 		} else if tool.IsEcho() {
 			return e.runEcho(tool)
+		} else if tool.IsInterpTemplateText() {
+			return e.runInterpTemplateText(ctx, tool, input)
 		}
+
 		s, err := e.runCommand(ctx, tool, input, ctx.ToolCategory)
 		if err != nil {
 			return nil, err

pkg/engine/interpreter_template.go

@@ -0,0 +1,100 @@
+package engine
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"text/template"
+
+	"github.com/gptscript-ai/gptscript/pkg/counter"
+	"github.com/gptscript-ai/gptscript/pkg/types"
+)
+
+func (e *Engine) runInterpTemplateText(ctx Context, tool types.Tool, input string) (*Return, error) {
+	// get code to eval
+	_, script, _ := strings.Cut(ctx.Tool.Instructions, "\n")
+	if script == "" {
+		return nil, nil
+	}
+
+	// setup environment for the interpreter
+	tmplData, err := prepareData(&ctx, input)
+	if err != nil {
+		return nil, err
+	}
+
+	tt, err := template.New(tool.Name).Funcs(prepareFuncMap()).Parse(script)
+	if err != nil {
+		return nil, err
+	}
+
+	// eval code
+	var tplOut bytes.Buffer
+	err = tt.Execute(&tplOut, tmplData)
+	if err != nil {
+		return nil, err
+	}
+	out := tplOut.String()
+
+	e.Progress <- types.CompletionStatus{
+		CompletionID: counter.Next(),
+		Response: map[string]any{
+			"output": out,
+			"err":    nil,
+		},
+	}
+
+	return &Return{
+		Result: &out,
+	}, nil
+}
+
+func prepareData(engineContext *Context, input string) (any, error) {
+	// get input
+	IN := map[string]any{
+		"input": "",
+	}
+	if input != "" {
+		err := json.Unmarshal([]byte(input), &IN)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// names kept uppercase just for testing to match (kind of) env variables
+	return map[string]any{
+		"INPUT":             IN["input"],
+		"GPTSCRIPT_INPUT":   input,
+		"GPTSCRIPT_CONTEXT": engineContext, // full engine context just to test atm
+	}, nil
+}
+
+// test helper functions
+func prepareFuncMap() template.FuncMap {
+	return template.FuncMap{
+		"join":       strings.Join,
+		"split":      strings.Split,
+		"fields":     strings.Fields,
+		"trim":       strings.Trim,
+		"trimSpace":  strings.TrimSpace,
+		"trimPrefix": strings.TrimPrefix,
+		"cutPrefix": func(s string, prefix string) string {
+			after, _ := strings.CutPrefix(s, prefix)
+			return after
+		},
+		"cut": func(s string, sep string) map[string]string {
+			before, after, _ := strings.Cut(s, sep)
+			return map[string]string{"before": before, "after": after}
+		},
+		"hasPrefix": strings.HasPrefix,
+		"append": func(slice []string, elems ...string) []string {
+			return append(slice, elems...)
+		},
+		"newSlice": func(args ...string) []string {
+			if len(args) == 0 {
+				return []string{}
+			}
+			return args
+		},
+	}
+}

pkg/types/tool.go

@@ -16,10 +16,11 @@ import (
 )
 
 const (
-	DaemonPrefix  = "#!sys.daemon"
-	OpenAPIPrefix = "#!sys.openapi"
-	EchoPrefix    = "#!sys.echo"
-	CommandPrefix = "#!"
+	InterpTemplateTextPrefix = "#!sys.interp.template.text"
+	DaemonPrefix             = "#!sys.daemon"
+	OpenAPIPrefix            = "#!sys.openapi"
+	EchoPrefix               = "#!sys.echo"
+	CommandPrefix            = "#!"
 )
 
 var (
@@ -898,6 +899,10 @@ func (t Tool) IsHTTP() bool {
 		strings.HasPrefix(t.Instructions, "#!https://")
 }
 
+func (t Tool) IsInterpTemplateText() bool {
+	return strings.HasPrefix(t.Instructions, InterpTemplateTextPrefix)
+}
+
 func FirstSet[T comparable](in ...T) (result T) {
 	for _, i := range in {
 		if i != result {