feat: add sys.chat.history

This allows multi agent flows to recall previous conversations

Author: ibuildthecloud

pkg/builtin/builtin.go

@@ -20,15 +20,17 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/BurntSushi/locker"
 	"github.com/google/shlex"
+	"github.com/gptscript-ai/gptscript/pkg/engine"
 	"github.com/gptscript-ai/gptscript/pkg/types"
 	"github.com/jaytaylor/html2text"
 )
 
 var SafeTools = map[string]struct{}{
-	"sys.echo":        {},
-	"sys.time.now":    {},
-	"sys.prompt":      {},
-	"sys.chat.finish": {},
+	"sys.echo":         {},
+	"sys.time.now":     {},
+	"sys.prompt":       {},
+	"sys.chat.finish":  {},
+	"sys.chat.history": {},
 }
 
 var tools = map[string]types.Tool{
@@ -182,6 +184,13 @@ var tools = map[string]types.Tool{
 		},
 		BuiltinFunc: SysPrompt,
 	},
+	"sys.chat.history": {
+		Parameters: types.Parameters{
+			Description: "Retrieves the previous chat dialog",
+			Arguments:   types.ObjectSchema(),
+		},
+		BuiltinFunc: SysChatHistory,
+	},
 }
 
 func SysProgram() *types.Program {
@@ -567,6 +576,33 @@ func (e *ErrChatFinish) Error() string {
 	return fmt.Sprintf("CHAT FINISH: %s", e.Message)
 }
 
+func SysChatHistory(ctx context.Context, _ []string, _ string) (string, error) {
+	engineContext, _ := engine.FromContext(ctx)
+
+	data, err := json.Marshal(engine.ChatHistory{
+		History: writeHistory(engineContext),
+	})
+
+	return string(data), err
+}
+
+func writeHistory(ctx *engine.Context) (result []engine.ChatHistoryCall) {
+	if ctx == nil {
+		return nil
+	}
+	if ctx.Parent != nil {
+		result = append(result, writeHistory(ctx.Parent)...)
+	}
+	if ctx.LastReturn != nil && ctx.LastReturn.State != nil {
+		result = append(result, engine.ChatHistoryCall{
+			ID:         ctx.ID,
+			Tool:       ctx.Tool,
+			Completion: ctx.LastReturn.State.Completion,
+		})
+	}
+	return
+}
+
 func SysChatFinish(ctx context.Context, env []string, input string) (string, error) {
 	var params struct {
 		Message string `json:"return,omitempty"`

pkg/engine/cmd.go

@@ -21,7 +21,7 @@ import (
 	"github.com/gptscript-ai/gptscript/pkg/version"
 )
 
-func (e *Engine) runCommand(ctx context.Context, tool types.Tool, input string, toolCategory ToolCategory) (cmdOut string, cmdErr error) {
+func (e *Engine) runCommand(ctx Context, tool types.Tool, input string, toolCategory ToolCategory) (cmdOut string, cmdErr error) {
 	id := counter.Next()
 
 	defer func() {
@@ -42,10 +42,18 @@ func (e *Engine) runCommand(ctx context.Context, tool types.Tool, input string,
 				"input":   input,
 			},
 		}
-		return tool.BuiltinFunc(ctx, e.Env, input)
+		return tool.BuiltinFunc(ctx.WrappedContext(), e.Env, input)
 	}
 
-	cmd, stop, err := e.newCommand(ctx, nil, tool, input)
+	var instructions []string
+	for _, inputContext := range ctx.InputContext {
+		instructions = append(instructions, inputContext.Content)
+	}
+	var extraEnv = []string{
+		strings.TrimSpace(fmt.Sprintf("GPTSCRIPT_CONTEXT=%s", strings.Join(instructions, "\n"))),
+	}
+
+	cmd, stop, err := e.newCommand(ctx.Ctx, extraEnv, tool, input)
 	if err != nil {
 		return "", err
 	}
@@ -66,7 +74,7 @@ func (e *Engine) runCommand(ctx context.Context, tool types.Tool, input string,
 	cmd.Stdout = io.MultiWriter(all, output)
 
 	if toolCategory == CredentialToolCategory {
-		pause := context2.GetPauseFuncFromCtx(ctx)
+		pause := context2.GetPauseFuncFromCtx(ctx.Ctx)
 		unpause := pause()
 		defer unpause()
 	}

pkg/engine/engine.go

@@ -69,9 +69,20 @@ type CallContext struct {
 
 type Context struct {
 	commonContext
-	Ctx     context.Context
-	Parent  *Context
-	Program *types.Program
+	Ctx        context.Context
+	Parent     *Context
+	LastReturn *Return
+	Program    *types.Program
+}
+
+type ChatHistory struct {
+	History []ChatHistoryCall `json:"history,omitempty"`
+}
+
+type ChatHistoryCall struct {
+	ID         string                  `json:"id,omitempty"`
+	Tool       types.Tool              `json:"tool,omitempty"`
+	Completion types.CompletionRequest `json:"completion,omitempty"`
 }
 
 type ToolCategory string
@@ -194,7 +205,7 @@ func (e *Engine) Start(ctx Context, input string) (ret *Return, _ error) {
 		} else if tool.IsEcho() {
 			return e.runEcho(tool)
 		}
-		s, err := e.runCommand(ctx.WrappedContext(), tool, input, ctx.ToolCategory)
+		s, err := e.runCommand(ctx, tool, input, ctx.ToolCategory)
 		if err != nil {
 			return nil, err
 		}
@@ -233,6 +244,10 @@ func (e *Engine) Start(ctx Context, input string) (ret *Return, _ error) {
 		input = ""
 	}
 
+	if tool.Chat && input == "{}" {
+		input = ""
+	}
+
 	if input != "" {
 		completion.Messages = append(completion.Messages, types.CompletionMessage{
 			Role:    types.CompletionMessageRoleTypeUser,

pkg/runner/runner.go

@@ -711,6 +711,10 @@ func (r *Runner) subCalls(callCtx engine.Context, monitor Monitor, env []string,
 		resultLock sync.Mutex
 	)
 
+	if state.Continuation != nil {
+		callCtx.LastReturn = state.Continuation
+	}
+
 	if state.InputContextContinuation != nil {
 		return state, nil, nil
 	}

pkg/types/completion.go

@@ -9,15 +9,14 @@ import (
 )
 
 type CompletionRequest struct {
-	Model                string
-	InternalSystemPrompt *bool
-	Tools                []CompletionTool
-	Messages             []CompletionMessage
-	MaxTokens            int
-	Temperature          *float32
-	JSONResponse         bool
-	Grammar              string
-	Cache                *bool
+	Model                string              `json:"model,omitempty"`
+	InternalSystemPrompt *bool               `json:"internalSystemPrompt,omitempty"`
+	Tools                []CompletionTool    `json:"tools,omitempty"`
+	Messages             []CompletionMessage `json:"messages,omitempty"`
+	MaxTokens            int                 `json:"maxTokens,omitempty"`
+	Temperature          *float32            `json:"temperature,omitempty"`
+	JSONResponse         bool                `json:"jsonResponse,omitempty"`
+	Cache                *bool               `json:"cache,omitempty"`
 }
 
 func (r *CompletionRequest) GetCache() bool {
@@ -57,6 +56,20 @@ type CompletionMessage struct {
 	Usage    Usage               `json:"usage,omitempty"`
 }
 
+func (c CompletionMessage) ChatText() string {
+	var buf strings.Builder
+	for _, part := range c.Content {
+		if part.Text == "" {
+			continue
+		}
+		if buf.Len() > 0 {
+			buf.WriteString(" ")
+		}
+		buf.WriteString(part.Text)
+	}
+	return buf.String()
+}
+
 type Usage struct {
 	PromptTokens     int `json:"promptTokens,omitempty"`
 	CompletionTokens int `json:"completionTokens,omitempty"`
@@ -73,8 +86,8 @@ type CompletionStatus struct {
 	PartialResponse *CompletionMessage
 }
 
-func (in CompletionMessage) IsToolCall() bool {
-	for _, content := range in.Content {
+func (c CompletionMessage) IsToolCall() bool {
+	for _, content := range c.Content {
 		if content.ToolCall != nil {
 			return true
 		}
@@ -90,9 +103,9 @@ func Text(text string) []ContentPart {
 	}
 }
 
-func (in CompletionMessage) String() string {
+func (c CompletionMessage) String() string {
 	buf := strings.Builder{}
-	for i, content := range in.Content {
+	for i, content := range c.Content {
 		if i > 0 {
 			buf.WriteString("\n")
 		}