chore: add sys.call

Author: ibuildthecloud

pkg/chat/chat.go

@@ -51,25 +51,30 @@ func Start(ctx context.Context, prevState runner.ChatState, chatter Chatter, prg
 			resp  runner.ChatResponse
 		)
 
-		prg, err := prg()
+		prog, err := prg()
 		if err != nil {
 			return err
 		}
 
-		prompter.SetPrompt(getPrompt(prg, prevResp))
+		prompter.SetPrompt(getPrompt(prog, prevResp))
 
 		if startInput != "" {
 			input = startInput
 			startInput = ""
-		} else if targetTool := prg.ToolSet[prg.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 {
 				return err
 			}
+
+			prog, err = prg()
+			if err != nil {
+				return err
+			}
 		}
 
-		resp, err = chatter.Chat(ctx, prevState, prg, env, input)
+		resp, err = chatter.Chat(ctx, prevState, prog, env, input)
 		if err != nil {
 			return err
 		}

pkg/cli/eval.go

@@ -75,7 +75,9 @@ func (e *Eval) Run(cmd *cobra.Command, args []string) error {
 
 	if e.Chat {
 		return chat.Start(cmd.Context(), nil, runner, func() (types.Program, error) {
-			return prg, nil
+			return loader.ProgramFromSource(cmd.Context(), tool.String(), "", loader.Options{
+				Cache: runner.Cache,
+			})
 		}, os.Environ(), toolInput, "")
 	}
 

pkg/credentials/credential.go

@@ -55,13 +55,8 @@ func (c Credential) toDockerAuthConfig() (types.AuthConfig, error) {
 func credentialFromDockerAuthConfig(authCfg types.AuthConfig) (Credential, error) {
 	var cred Credential
 	if authCfg.Password != "" {
-		if err := json.Unmarshal([]byte(authCfg.Password), &cred); err != nil || len(cred.Env) == 0 {
-			// Legacy: try unmarshalling into just an env map
-			var env map[string]string
-			if err := json.Unmarshal([]byte(authCfg.Password), &env); err != nil {
-				return Credential{}, err
-			}
-			cred.Env = env
+		if err := json.Unmarshal([]byte(authCfg.Password), &cred); err != nil {
+			return cred, fmt.Errorf("failed to unmarshal credential: %w", err)
 		}
 	}
 

pkg/engine/call.go

@@ -0,0 +1,92 @@
+package engine
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/gptscript-ai/gptscript/pkg/types"
+)
+
+func (e *Engine) runCall(ctx Context, tool types.Tool, input string) (*Return, error) {
+	interpreter, body, _ := strings.Cut(tool.Instructions, "\n")
+
+	fields := strings.Fields(interpreter)
+	if len(fields) < 2 {
+		return nil, fmt.Errorf("invalid tool call, no target tool found in %s", tool.Instructions)
+	}
+	toolRef := strings.Join(fields[1:], " ")
+
+	toolName, args := types.SplitArg(toolRef)
+
+	toolNameParts := strings.Fields(toolName)
+
+	toolName = toolNameParts[0]
+	toolNameArgs := toolNameParts[1:]
+
+	targetTools, ok := tool.ToolMapping[toolName]
+	if !ok || len(targetTools) == 0 {
+		return nil, fmt.Errorf("target tool %s not found, must reference in `tools:` fields", toolName)
+	}
+
+	ref := types.ToolReference{
+		Reference: toolName,
+		Arg:       args,
+		ToolID:    targetTools[0].ToolID,
+	}
+
+	newInput, err := types.GetToolRefInput(ctx.Program, ref, input)
+	if err != nil {
+		return nil, err
+	}
+
+	newInput, err = mergeInputs(input, newInput)
+	if err != nil {
+		return nil, fmt.Errorf("failed to merge inputs: %w", err)
+	}
+
+	newInput, err = mergeInputs(newInput, toString(map[string]string{
+		"TOOL_CALL_ARGS": strings.Join(toolNameArgs, " "),
+		"TOOL_CALL_BODY": body,
+	}))
+
+	newCtx := ctx
+	newCtx.Tool = ctx.Program.ToolSet[ref.ToolID]
+
+	return e.Start(newCtx, newInput)
+}
+
+func toString(data map[string]string) string {
+	out, err := json.Marshal(data)
+	if err != nil {
+		// this will never happen
+		panic(err)
+	}
+	return string(out)
+}
+
+func mergeInputs(base, overlay string) (string, error) {
+	baseMap := map[string]interface{}{}
+	overlayMap := map[string]interface{}{}
+
+	if overlay == "" || overlay == "{}" {
+		return base, nil
+	}
+
+	err := json.Unmarshal([]byte(base), &baseMap)
+	if err != nil {
+		return "", fmt.Errorf("failed to unmarshal base input: %w", err)
+	}
+
+	err = json.Unmarshal([]byte(overlay), &overlayMap)
+	if err != nil {
+		return "", fmt.Errorf("failed to unmarshal overlay input: %w", err)
+	}
+
+	for k, v := range overlayMap {
+		baseMap[k] = v
+	}
+
+	out, err := json.Marshal(baseMap)
+	return string(out), err
+}

pkg/engine/engine.go

@@ -286,6 +286,8 @@ func (e *Engine) runCommandTools(ctx Context, tool types.Tool, input string) (*R
 		return e.runOpenAPI(tool, input)
 	} else if tool.IsEcho() {
 		return e.runEcho(tool)
+	} else if tool.IsCall() {
+		return e.runCall(ctx, tool, input)
 	}
 	s, err := e.runCommand(ctx, tool, input, ctx.ToolCategory)
 	if err != nil {

pkg/runner/output.go

@@ -19,7 +19,7 @@ func argsForFilters(prg *types.Program, tool types.ToolReference, startState *St
 		startInput = *startState.StartInput
 	}
 
-	parsedArgs, err := getToolRefInput(prg, tool, startInput)
+	parsedArgs, err := types.GetToolRefInput(prg, tool, startInput)
 	if err != nil {
 		return "", err
 	}

pkg/runner/runner.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"sort"
-	"strings"
 	"sync"
 	"time"
 
@@ -245,92 +244,6 @@ var (
 	EventTypeRunFinish    EventType = "runFinish"
 )
 
-func getToolRefInput(prg *types.Program, ref types.ToolReference, input string) (string, error) {
-	if ref.Arg == "" {
-		return "", nil
-	}
-
-	targetArgs := prg.ToolSet[ref.ToolID].Arguments
-	targetKeys := map[string]string{}
-
-	if ref.Arg == "*" {
-		return input, nil
-	}
-
-	if targetArgs == nil {
-		return "", nil
-	}
-
-	for targetKey := range targetArgs.Properties {
-		targetKeys[strings.ToLower(targetKey)] = targetKey
-	}
-
-	inputMap := map[string]interface{}{}
-	outputMap := map[string]interface{}{}
-
-	_ = json.Unmarshal([]byte(input), &inputMap)
-	for k, v := range inputMap {
-		inputMap[strings.ToLower(k)] = v
-	}
-
-	fields := strings.Fields(ref.Arg)
-
-	for i := 0; i < len(fields); i++ {
-		field := fields[i]
-		if field == "and" {
-			continue
-		}
-		if field == "as" {
-			i++
-			continue
-		}
-
-		var (
-			keyName string
-			val     any
-		)
-
-		if strings.HasPrefix(field, "$") {
-			key := strings.TrimPrefix(field, "$")
-			key = strings.TrimPrefix(key, "{")
-			key = strings.TrimSuffix(key, "}")
-			val = inputMap[strings.ToLower(key)]
-		} else {
-			val = field
-		}
-
-		if len(fields) > i+1 && fields[i+1] == "as" {
-			keyName = strings.ToLower(fields[i+2])
-		}
-
-		if len(targetKeys) == 0 {
-			return "", fmt.Errorf("can not assign arg to context because target tool [%s] has no defined args", ref.ToolID)
-		}
-
-		if keyName == "" {
-			if len(targetKeys) != 1 {
-				return "", fmt.Errorf("can not assign arg to context because target tool [%s] has does not have one args. You must use \"as\" syntax to map the arg to a key %v", ref.ToolID, targetKeys)
-			}
-			for k := range targetKeys {
-				keyName = k
-			}
-		}
-
-		if targetKey, ok := targetKeys[strings.ToLower(keyName)]; ok {
-			outputMap[targetKey] = val
-		} else {
-			return "", fmt.Errorf("can not assign arg to context because target tool [%s] has does not args [%s]", ref.ToolID, keyName)
-		}
-	}
-
-	if len(outputMap) == 0 {
-		return "", nil
-	}
-
-	output, err := json.Marshal(outputMap)
-	return string(output), err
-}
-
 func (r *Runner) getContext(callCtx engine.Context, state *State, monitor Monitor, env []string, input string) (result []engine.InputContext, _ error) {
 	toolRefs, err := callCtx.Tool.GetToolsByType(callCtx.Program, types.ToolTypeContext)
 	if err != nil {
@@ -343,7 +256,7 @@ func (r *Runner) getContext(callCtx engine.Context, state *State, monitor Monito
 			continue
 		}
 
-		contextInput, err := getToolRefInput(callCtx.Program, toolRef, input)
+		contextInput, err := types.GetToolRefInput(callCtx.Program, toolRef, input)
 		if err != nil {
 			return nil, err
 		}
@@ -878,18 +791,9 @@ func (r *Runner) handleCredentials(callCtx engine.Context, monitor Monitor, env
 			refresh          bool
 		)
 
-		// Only try to look up the cred if the tool is on GitHub or has an alias.
-		// If it is a GitHub tool and has an alias, the alias overrides the tool name, so we use it as the credential name.
-		if isGitHubTool(toolName) && credentialAlias == "" {
-			c, exists, err = r.credStore.Get(callCtx.Ctx, toolName)
-			if err != nil {
-				return nil, fmt.Errorf("failed to get credentials for tool %s: %w", toolName, err)
-			}
-		} else if credentialAlias != "" {
-			c, exists, err = r.credStore.Get(callCtx.Ctx, credentialAlias)
-			if err != nil {
-				return nil, fmt.Errorf("failed to get credential %s: %w", credentialAlias, err)
-			}
+		c, exists, err = r.credStore.Get(callCtx.Ctx, credName)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get credentials for tool %s: %w", toolName, err)
 		}
 
 		if c == nil {
@@ -955,22 +859,17 @@ func (r *Runner) handleCredentials(callCtx engine.Context, monitor Monitor, env
 			}
 
 			if !resultCredential.Ephemeral {
-				// Only store the credential if the tool is on GitHub or has an alias, and the credential is non-empty.
-				if (isGitHubTool(toolName) && callCtx.Program.ToolSet[ref.ToolID].Source.Repo != nil) || credentialAlias != "" {
-					if isEmpty {
-						log.Warnf("Not saving empty credential for tool %s", toolName)
+				if isEmpty {
+					log.Warnf("Not saving empty credential for tool %s", toolName)
+				} else {
+					if refresh {
+						err = r.credStore.Refresh(callCtx.Ctx, resultCredential)
 					} else {
-						if refresh {
-							err = r.credStore.Refresh(callCtx.Ctx, resultCredential)
-						} else {
-							err = r.credStore.Add(callCtx.Ctx, resultCredential)
-						}
-						if err != nil {
-							return nil, fmt.Errorf("failed to save credential for tool %s: %w", toolName, err)
-						}
+						err = r.credStore.Add(callCtx.Ctx, resultCredential)
+					}
+					if err != nil {
+						return nil, fmt.Errorf("failed to save credential for tool %s: %w", toolName, err)
 					}
-				} else {
-					log.Warnf("Not saving credential for tool %s - credentials will only be saved for tools from GitHub, or tools that use aliases.", toolName)
 				}
 			}
 		} else {
@@ -992,7 +891,3 @@ func (r *Runner) handleCredentials(callCtx engine.Context, monitor Monitor, env
 
 	return env, nil
 }
-
-func isGitHubTool(toolName string) bool {
-	return strings.HasPrefix(toolName, "github.com")
-}