Add sys.read and sys.write

Author: ibuildthecloud

pkg/builtin/builtin.go

@@ -0,0 +1,68 @@
+package builtin
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"os"
+	"unicode/utf8"
+
+	"github.com/acorn-io/gptscript/pkg/types"
+)
+
+var Tools = map[string]types.Tool{
+	"sys.read": {
+		Description: "Reads the contents of a file",
+		Arguments: types.ObjectSchema(
+			"filename", "The name of the file to read"),
+		BuiltinFunc: func(ctx context.Context, env []string, input string) (string, error) {
+			var params struct {
+				Filename string `json:"filename,omitempty"`
+			}
+			if err := json.Unmarshal([]byte(input), &params); err != nil {
+				return "", err
+			}
+
+			log.Debugf("Reading file %s", params.Filename)
+			data, err := os.ReadFile(params.Filename)
+			if err != nil {
+				return "", err
+			}
+
+			if utf8.Valid(data) {
+				return string(data), nil
+			}
+			return base64.StdEncoding.EncodeToString(data), nil
+		},
+	},
+	"sys.write": {
+		Description: "Write the contents to a file",
+		Arguments: types.ObjectSchema(
+			"filename", "The name of the file to write to",
+			"content", "The content to write"),
+		BuiltinFunc: func(ctx context.Context, env []string, input string) (string, error) {
+			var params struct {
+				Filename string `json:"filename,omitempty"`
+				Content  string `json:"content,omitempty"`
+			}
+			if err := json.Unmarshal([]byte(input), &params); err != nil {
+				return "", err
+			}
+
+			data := []byte(params.Content)
+			msg := fmt.Sprintf("Wrote %d bytes to file %s", len(data), params.Filename)
+			log.Debugf(msg)
+
+			return "", os.WriteFile(params.Filename, data, 0644)
+		},
+	},
+}
+
+func Builtin(name string) (types.Tool, bool) {
+	t, ok := Tools[name]
+	t.Name = name
+	t.ID = name
+	t.Instructions = "#!" + name
+	return t, ok
+}

pkg/builtin/log.go

@@ -0,0 +1,5 @@
+package builtin
+
+import "github.com/acorn-io/gptscript/pkg/mvl"
+
+var log = mvl.Package()

pkg/engine/engine.go

@@ -137,7 +137,11 @@ func (c *Context) getTool(name string) (types.Tool, error) {
 	return tool, nil
 }
 
-func (e *Engine) runCommand(tool types.Tool, input string) (string, error) {
+func (e *Engine) runCommand(ctx context.Context, tool types.Tool, input string) (string, error) {
+	if tool.BuiltinFunc != nil {
+		return tool.BuiltinFunc(ctx, e.Env, input)
+	}
+
 	env := e.Env[:]
 	data := map[string]any{}
 
@@ -197,7 +201,7 @@ func (e *Engine) Start(ctx Context, input string) (*Return, error) {
 	tool := ctx.Tool
 
 	if tool.IsCommand() {
-		s, err := e.runCommand(tool, input)
+		s, err := e.runCommand(ctx.Ctx, tool, input)
 		if err != nil {
 			return nil, err
 		}

pkg/loader/loader.go

@@ -19,6 +19,7 @@ import (
 	"strings"
 
 	"github.com/acorn-io/gptscript/pkg/assemble"
+	"github.com/acorn-io/gptscript/pkg/builtin"
 	"github.com/acorn-io/gptscript/pkg/parser"
 	"github.com/acorn-io/gptscript/pkg/types"
 )
@@ -332,6 +333,14 @@ func Program(ctx context.Context, name, subToolName string) (types.Program, erro
 }
 
 func Resolve(ctx context.Context, prg *types.Program, base *Source, name, subTool string) (types.Tool, error) {
+	if subTool == "" {
+		t, ok := builtin.Builtin(name)
+		if ok {
+			prg.ToolSet[t.ID] = t
+			return t, nil
+		}
+	}
+
 	s, err := Input(ctx, base, name)
 	if err != nil {
 		return types.Tool{}, err

pkg/types/jsonschema.go

@@ -16,6 +16,24 @@ type JSONSchema struct {
 	AdditionalProperties bool `json:"additionalProperties,omitempty"`
 }
 
+func ObjectSchema(kv ...string) *JSONSchema {
+	s := &JSONSchema{
+		Property: Property{
+			Type: "object",
+		},
+		Properties: map[string]Property{},
+	}
+	for i, v := range kv {
+		if i%2 == 1 {
+			s.Properties[kv[i-1]] = Property{
+				Description: v,
+				Type:        "string",
+			}
+		}
+	}
+	return s
+}
+
 type Property struct {
 	Description string       `json:"description,omitempty"`
 	Type        string       `json:"type,omitempty"`

pkg/types/tool.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	"context"
 	"fmt"
 	"strings"
 )
@@ -12,6 +13,8 @@ type Program struct {
 	ToolSet     ToolSet `json:"toolSet,omitempty"`
 }
 
+type BuiltinFunc func(ctx context.Context, env []string, input string) (string, error)
+
 type Tool struct {
 	ID           string            `json:"id,omitempty"`
 	Name         string            `json:"name,omitempty"`
@@ -20,6 +23,7 @@ type Tool struct {
 	Instructions string            `json:"instructions,omitempty"`
 	Tools        []string          `json:"tools,omitempty"`
 	ToolMapping  map[string]string `json:"toolMapping,omitempty"`
+	BuiltinFunc  BuiltinFunc       `json:"-"`
 
 	Vision       bool   `json:"vision,omitempty"`
 	MaxTokens    int    `json:"maxTokens,omitempty"`