feat: add input filters

pkg/engine/cmd.go

@@ -185,6 +185,8 @@ func appendInputAsEnv(env []string, input string) []string {
 	dec := json.NewDecoder(bytes.NewReader([]byte(input)))
 	dec.UseNumber()
 
+	env = appendEnv(env, "GPTSCRIPT_INPUT", input)
+
 	if err := json.Unmarshal([]byte(input), &data); err != nil {
 		// ignore invalid JSON
 		return env
@@ -206,7 +208,6 @@ func appendInputAsEnv(env []string, input string) []string {
 		}
 	}
 
-	env = appendEnv(env, "GPTSCRIPT_INPUT", input)
 	return env
 }
 

pkg/engine/engine.go

@@ -98,6 +98,7 @@ const (
 	ProviderToolCategory   ToolCategory = "provider"
 	CredentialToolCategory ToolCategory = "credential"
 	ContextToolCategory    ToolCategory = "context"
+	InputToolCategory      ToolCategory = "input"
 	NoCategory             ToolCategory = ""
 )
 
@@ -180,7 +181,7 @@ func NewContext(ctx context.Context, prg *types.Program, input string) Context {
 	return callCtx
 }
 
-func (c *Context) SubCall(ctx context.Context, input, toolID, callID string, toolCategory ToolCategory) (Context, error) {
+func (c *Context) SubCallContext(ctx context.Context, input, toolID, callID string, toolCategory ToolCategory) (Context, error) {
 	tool, ok := c.Program.ToolSet[toolID]
 	if !ok {
 		return Context{}, fmt.Errorf("failed to file tool for id [%s]", toolID)

pkg/openai/client.go

@@ -2,7 +2,6 @@ package openai
 
 import (
 	"context"
-	"fmt"
 	"io"
 	"log/slog"
 	"os"
@@ -16,6 +15,7 @@ import (
 	"github.com/gptscript-ai/gptscript/pkg/counter"
 	"github.com/gptscript-ai/gptscript/pkg/credentials"
 	"github.com/gptscript-ai/gptscript/pkg/hash"
+	"github.com/gptscript-ai/gptscript/pkg/mvl"
 	"github.com/gptscript-ai/gptscript/pkg/prompt"
 	"github.com/gptscript-ai/gptscript/pkg/system"
 	"github.com/gptscript-ai/gptscript/pkg/types"
@@ -29,6 +29,7 @@ const (
 var (
 	key = os.Getenv("OPENAI_API_KEY")
 	url = os.Getenv("OPENAI_BASE_URL")
+	log = mvl.Package()
 )
 
 type InvalidAuthError struct{}
@@ -305,7 +306,11 @@ func (c *Client) Call(ctx context.Context, messageRequest types.CompletionReques
 	}
 
 	if len(msgs) == 0 {
-		return nil, fmt.Errorf("invalid request, no messages to send to LLM")
+		log.Errorf("invalid request, no messages to send to LLM")
+		return &types.CompletionMessage{
+			Role:    types.CompletionMessageRoleTypeAssistant,
+			Content: types.Text(""),
+		}, nil
 	}
 
 	request := openai.ChatCompletionRequest{

pkg/parser/parser.go

@@ -105,6 +105,10 @@ func isParam(line string, tool *types.Tool) (_ bool, err error) {
 		tool.Parameters.Export = append(tool.Parameters.Export, csv(value)...)
 	case "tool", "tools":
 		tool.Parameters.Tools = append(tool.Parameters.Tools, csv(value)...)
+	case "inputfilter", "inputfilters":
+		tool.Parameters.InputFilters = append(tool.Parameters.InputFilters, csv(value)...)
+	case "shareinputfilter", "shareinputfilters":
+		tool.Parameters.ExportInputFilters = append(tool.Parameters.ExportInputFilters, csv(value)...)
 	case "agent", "agents":
 		tool.Parameters.Agents = append(tool.Parameters.Agents, csv(value)...)
 	case "globaltool", "globaltools":
@@ -183,10 +187,13 @@ 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 != "" ||
-		len(c.tool.Export) > 0 || len(c.tool.Tools) > 0 ||
+	if c.tool.Instructions != "" ||
+		c.tool.Parameters.Name != "" ||
+		len(c.tool.Export) > 0 ||
+		len(c.tool.Tools) > 0 ||
 		c.tool.GlobalModelName != "" ||
 		len(c.tool.GlobalTools) > 0 ||
+		len(c.tool.ExportInputFilters) > 0 ||
 		c.tool.Chat {
 		*tools = append(*tools, Node{
 			ToolNode: &ToolNode{

pkg/parser/parser_test.go

@@ -191,3 +191,27 @@ name: bad
 		},
 	}}).Equal(t, out)
 }
+
+func TestParseInput(t *testing.T) {
+	input := `
+input filters: input
+share input filters: shared
+`
+	out, err := Parse(strings.NewReader(input))
+	require.NoError(t, err)
+	autogold.Expect(Document{Nodes: []Node{
+		{ToolNode: &ToolNode{
+			Tool: types.Tool{
+				ToolDef: types.ToolDef{
+					Parameters: types.Parameters{
+						InputFilters: []string{
+							"input",
+						},
+						ExportInputFilters: []string{"shared"},
+					},
+				},
+				Source: types.ToolSource{LineNo: 1},
+			},
+		}},
+	}}).Equal(t, out)
+}

pkg/runner/input.go

@@ -0,0 +1,27 @@
+package runner
+
+import (
+	"fmt"
+
+	"github.com/gptscript-ai/gptscript/pkg/engine"
+)
+
+func (r *Runner) handleInput(callCtx engine.Context, monitor Monitor, env []string, input string) (string, error) {
+	inputToolRefs, err := callCtx.Tool.GetInputFilterTools(*callCtx.Program)
+	if err != nil {
+		return "", err
+	}
+
+	for _, inputToolRef := range inputToolRefs {
+		res, err := r.subCall(callCtx.Ctx, callCtx, monitor, env, inputToolRef.ToolID, input, "", engine.InputToolCategory)
+		if err != nil {
+			return "", err
+		}
+		if res.Result == nil {
+			return "", fmt.Errorf("invalid state: input tool [%s] can not result in a chat continuation", inputToolRef.Reference)
+		}
+		input = *res.Result
+	}
+
+	return input, nil
+}

pkg/runner/runner.go

@@ -408,6 +408,11 @@ func (r *Runner) start(callCtx engine.Context, state *State, monitor Monitor, en
 		Content:     input,
 	})
 
+	input, err := r.handleInput(callCtx, monitor, env, input)
+	if err != nil {
+		return nil, err
+	}
+
 	if len(callCtx.Tool.Credentials) > 0 {
 		var err error
 		env, err = r.handleCredentials(callCtx, monitor, env)
@@ -417,7 +422,6 @@ func (r *Runner) start(callCtx engine.Context, state *State, monitor Monitor, en
 	}
 
 	var (
-		err      error
 		newState *State
 	)
 	callCtx.InputContext, newState, err = r.getContext(callCtx, state, monitor, env, input)
@@ -446,7 +450,10 @@ func (r *Runner) start(callCtx engine.Context, state *State, monitor Monitor, en
 		}
 
 		if !authResp.Accept {
-			msg := fmt.Sprintf("[AUTHORIZATION ERROR]: %s", authResp.Message)
+			msg := authResp.Message
+			if msg == "" {
+				msg = "Tool call request has been denied"
+			}
 			return &State{
 				Continuation: &engine.Return{
 					Result: &msg,
@@ -631,8 +638,12 @@ func (r *Runner) resume(callCtx engine.Context, monitor Monitor, env []string, s
 		}
 
 		if state.ResumeInput != nil {
+			input, err := r.handleInput(callCtx, monitor, env, *state.ResumeInput)
+			if err != nil {
+				return state, err
+			}
 			engineResults = append(engineResults, engine.CallResult{
-				User: *state.ResumeInput,
+				User: input,
 			})
 		}
 
@@ -689,16 +700,22 @@ func streamProgress(callCtx *engine.Context, monitor Monitor) (chan<- types.Comp
 }
 
 func (r *Runner) subCall(ctx context.Context, parentContext engine.Context, monitor Monitor, env []string, toolID, input, callID string, toolCategory engine.ToolCategory) (*State, error) {
-	callCtx, err := parentContext.SubCall(ctx, input, toolID, callID, toolCategory)
+	callCtx, err := parentContext.SubCallContext(ctx, input, toolID, callID, toolCategory)
 	if err != nil {
 		return nil, err
 	}
 
+	if toolCategory == engine.ContextToolCategory && callCtx.Tool.IsNoop() {
+		return &State{
+			Result: new(string),
+		}, nil
+	}
+
 	return r.call(callCtx, monitor, env, input)
 }
 
 func (r *Runner) subCallResume(ctx context.Context, parentContext engine.Context, monitor Monitor, env []string, toolID, callID string, state *State, toolCategory engine.ToolCategory) (*State, error) {
-	callCtx, err := parentContext.SubCall(ctx, "", toolID, callID, toolCategory)
+	callCtx, err := parentContext.SubCallContext(ctx, "", toolID, callID, toolCategory)
 	if err != nil {
 		return nil, err
 	}
@@ -882,12 +899,7 @@ func (r *Runner) handleCredentials(callCtx engine.Context, monitor Monitor, env
 				input = string(inputBytes)
 			}
 
-			subCtx, err := callCtx.SubCall(callCtx.Ctx, input, credToolRefs[0].ToolID, "", engine.CredentialToolCategory) // leaving callID as "" will cause it to be set by the engine
-			if err != nil {
-				return nil, fmt.Errorf("failed to create subcall context for tool %s: %w", credToolName, err)
-			}
-
-			res, err := r.call(subCtx, monitor, env, input)
+			res, err := r.subCall(callCtx.Ctx, callCtx, monitor, env, credToolRefs[0].ToolID, input, "", engine.CredentialToolCategory)
 			if err != nil {
 				return nil, fmt.Errorf("failed to run credential tool %s: %w", credToolName, err)
 			}

pkg/tests/runner_test.go

@@ -822,3 +822,24 @@ func TestAgents(t *testing.T) {
 	autogold.Expect("TEST RESULT CALL: 4").Equal(t, resp.Content)
 	autogold.ExpectFile(t, toJSONString(t, resp), autogold.Name(t.Name()+"/step1"))
 }
+
+func TestInput(t *testing.T) {
+	r := tester.NewRunner(t)
+
+	prg, err := r.Load("")
+	require.NoError(t, err)
+
+	resp, err := r.Chat(context.Background(), nil, prg, nil, "You're stupid")
+	require.NoError(t, err)
+	r.AssertResponded(t)
+	assert.False(t, resp.Done)
+	autogold.Expect("TEST RESULT CALL: 1").Equal(t, resp.Content)
+	autogold.ExpectFile(t, toJSONString(t, resp), autogold.Name(t.Name()+"/step1"))
+
+	resp, err = r.Chat(context.Background(), resp.State, prg, nil, "You're ugly")
+	require.NoError(t, err)
+	r.AssertResponded(t)
+	assert.False(t, resp.Done)
+	autogold.Expect("TEST RESULT CALL: 2").Equal(t, resp.Content)
+	autogold.ExpectFile(t, toJSONString(t, resp), autogold.Name(t.Name()+"/step2"))
+}

pkg/tests/testdata/TestInput/call1-resp.golden

@@ -0,0 +1,9 @@
+`{
+  "role": "assistant",
+  "content": [
+    {
+      "text": "TEST RESULT CALL: 1"
+    }
+  ],
+  "usage": {}
+}`

pkg/tests/testdata/TestInput/call1.golden

@@ -0,0 +1,24 @@
+`{
+  "model": "gpt-4o",
+  "internalSystemPrompt": false,
+  "messages": [
+    {
+      "role": "system",
+      "content": [
+        {
+          "text": "\nTool body"
+        }
+      ],
+      "usage": {}
+    },
+    {
+      "role": "user",
+      "content": [
+        {
+          "text": "No, You're stupid!\n ha ha ha\n"
+        }
+      ],
+      "usage": {}
+    }
+  ]
+}`

pkg/tests/testdata/TestInput/step1.golden

@@ -0,0 +1,47 @@
+`{
+  "done": false,
+  "content": "TEST RESULT CALL: 1",
+  "toolID": "testdata/TestInput/test.gpt:",
+  "state": {
+    "continuation": {
+      "state": {
+        "input": "No, You're stupid!\n ha ha ha\n",
+        "completion": {
+          "model": "gpt-4o",
+          "internalSystemPrompt": false,
+          "messages": [
+            {
+              "role": "system",
+              "content": [
+                {
+                  "text": "\nTool body"
+                }
+              ],
+              "usage": {}
+            },
+            {
+              "role": "user",
+              "content": [
+                {
+                  "text": "No, You're stupid!\n ha ha ha\n"
+                }
+              ],
+              "usage": {}
+            },
+            {
+              "role": "assistant",
+              "content": [
+                {
+                  "text": "TEST RESULT CALL: 1"
+                }
+              ],
+              "usage": {}
+            }
+          ]
+        }
+      },
+      "result": "TEST RESULT CALL: 1"
+    },
+    "continuationToolID": "testdata/TestInput/test.gpt:"
+  }
+}`

pkg/tests/testdata/TestInput/test.gpt

@@ -0,0 +1,23 @@
+input filter: taunt
+context: exporter
+chat: true
+
+Tool body
+
+---
+name: taunt
+args: foo: this is useless
+#!/bin/bash
+
+echo "No, ${GPTSCRIPT_INPUT}!"
+
+---
+name: exporter
+share input filters: taunt2
+
+---
+name: taunt2
+args: foo: this is useless
+
+#!/bin/bash
+echo "${GPTSCRIPT_INPUT} ha ha ha"

pkg/types/set.go

@@ -29,7 +29,7 @@ func (t *toolRefSet) HasTool(toolID string) bool {
 }
 
 func (t *toolRefSet) AddAll(values []ToolReference, err error) {
-	if t.err != nil {
+	if err != nil {
 		t.err = err
 	}
 	for _, v := range values {