chore: drop input continuations feature

Author: ibuildthecloud

pkg/runner/runner.go

@@ -172,11 +172,7 @@ func (r *Runner) Chat(ctx context.Context, prevState ChatState, prg types.Progra
 		return resp, err
 	}
 
-	if state == nil || state.StartContinuation {
-		if state != nil {
-			state = state.WithResumeInput(&input)
-			input = state.InputContextContinuationInput
-		}
+	if state == nil {
 		state, err = r.start(callCtx, state, monitor, env, input)
 		if err != nil {
 			return resp, err
@@ -186,11 +182,9 @@ func (r *Runner) Chat(ctx context.Context, prevState ChatState, prg types.Progra
 		state.ResumeInput = &input
 	}
 
-	if !state.StartContinuation {
-		state, err = r.resume(callCtx, monitor, env, state)
-		if err != nil {
-			return resp, err
-		}
+	state, err = r.resume(callCtx, monitor, env, state)
+	if err != nil {
+		return resp, err
 	}
 
 	if state.Result != nil {
@@ -335,24 +329,10 @@ func getToolRefInput(prg *types.Program, ref types.ToolReference, input string)
 	return string(output), err
 }
 
-func (r *Runner) getContext(callCtx engine.Context, state *State, monitor Monitor, env []string, input string) (result []engine.InputContext, _ *State, _ error) {
+func (r *Runner) getContext(callCtx engine.Context, state *State, monitor Monitor, env []string, input string) (result []engine.InputContext, _ error) {
 	toolRefs, err := callCtx.Tool.GetContextTools(*callCtx.Program)
 	if err != nil {
-		return nil, nil, err
-	}
-
-	var newState *State
-	if state != nil {
-		cp := *state
-		newState = &cp
-		if newState.InputContextContinuation != nil {
-			newState.InputContexts = nil
-			newState.InputContextContinuation = nil
-			newState.InputContextContinuationInput = ""
-			newState.ResumeInput = state.InputContextContinuationResumeInput
-
-			input = state.InputContextContinuationInput
-		}
+		return nil, err
 	}
 
 	for i, toolRef := range toolRefs {
@@ -363,47 +343,31 @@ func (r *Runner) getContext(callCtx engine.Context, state *State, monitor Monito
 
 		contextInput, err := getToolRefInput(callCtx.Program, toolRef, input)
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 
 		var content *State
-		if state != nil && state.InputContextContinuation != nil {
-			content, err = r.subCallResume(callCtx.Ctx, callCtx, monitor, env, toolRef.ToolID, "", state.InputContextContinuation.WithResumeInput(state.ResumeInput), engine.ContextToolCategory)
-		} else {
-			content, err = r.subCall(callCtx.Ctx, callCtx, monitor, env, toolRef.ToolID, contextInput, "", engine.ContextToolCategory)
-		}
+		content, err = r.subCall(callCtx.Ctx, callCtx, monitor, env, toolRef.ToolID, contextInput, "", engine.ContextToolCategory)
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 		if content.Continuation != nil {
-			if newState == nil {
-				newState = &State{}
-			}
-			newState.InputContexts = result
-			newState.InputContextContinuation = content
-			newState.InputContextContinuationInput = input
-			if state != nil {
-				newState.InputContextContinuationResumeInput = state.ResumeInput
-			}
-			return nil, newState, nil
+			return nil, fmt.Errorf("invalid state: context tool [%s] can not result in a continuation", toolRef.ToolID)
 		}
 		result = append(result, engine.InputContext{
 			ToolID:  toolRef.ToolID,
 			Content: *content.Result,
 		})
 	}
 
-	return result, newState, nil
+	return result, nil
 }
 
 func (r *Runner) call(callCtx engine.Context, monitor Monitor, env []string, input string) (*State, error) {
 	result, err := r.start(callCtx, nil, monitor, env, input)
 	if err != nil {
 		return nil, err
 	}
-	if result.StartContinuation {
-		return result, nil
-	}
 	return r.resume(callCtx, monitor, env, result)
 }
 
@@ -435,15 +399,10 @@ func (r *Runner) start(callCtx engine.Context, state *State, monitor Monitor, en
 		}
 	}
 
-	var newState *State
-	callCtx.InputContext, newState, err = r.getContext(callCtx, state, monitor, env, input)
+	callCtx.InputContext, err = r.getContext(callCtx, state, monitor, env, input)
 	if err != nil {
 		return nil, err
 	}
-	if newState != nil && newState.InputContextContinuation != nil {
-		newState.StartContinuation = true
-		return newState, nil
-	}
 
 	e := engine.Engine{
 		Model:          r.c,
@@ -493,11 +452,7 @@ type State struct {
 	SubCalls    []SubCallResult `json:"subCalls,omitempty"`
 	SubCallID   string          `json:"subCallID,omitempty"`
 
-	InputContexts                       []engine.InputContext `json:"inputContexts,omitempty"`
-	InputContextContinuation            *State                `json:"inputContextContinuation,omitempty"`
-	InputContextContinuationInput       string                `json:"inputContextContinuationInput,omitempty"`
-	InputContextContinuationResumeInput *string               `json:"inputContextContinuationResumeInput,omitempty"`
-	StartContinuation                   bool                  `json:"startContinuation,omitempty"`
+	InputContexts []engine.InputContext `json:"inputContexts,omitempty"`
 }
 
 func (s State) WithResumeInput(input *string) *State {
@@ -510,10 +465,6 @@ func (s State) ContinuationContentToolID() (string, error) {
 		return s.ContinuationToolID, nil
 	}
 
-	if s.InputContextContinuation != nil {
-		return s.InputContextContinuation.ContinuationContentToolID()
-	}
-
 	for _, subCall := range s.SubCalls {
 		if s.SubCallID == subCall.CallID {
 			return subCall.State.ContinuationContentToolID()
@@ -527,10 +478,6 @@ func (s State) ContinuationContent() (string, error) {
 		return *s.Continuation.Result, nil
 	}
 
-	if s.InputContextContinuation != nil {
-		return s.InputContextContinuation.ContinuationContent()
-	}
-
 	for _, subCall := range s.SubCalls {
 		if s.SubCallID == subCall.CallID {
 			return subCall.State.ContinuationContent()
@@ -549,10 +496,6 @@ func (r *Runner) resume(callCtx engine.Context, monitor Monitor, env []string, s
 		retState, retErr = r.handleOutput(callCtx, monitor, env, retState, retErr)
 	}()
 
-	if state.StartContinuation {
-		return nil, fmt.Errorf("invalid state, resume should not have StartContinuation set to true")
-	}
-
 	if state.Continuation == nil {
 		return nil, errors.New("invalid state, resume should have Continuation data")
 	}
@@ -651,18 +594,18 @@ func (r *Runner) resume(callCtx engine.Context, monitor Monitor, env []string, s
 			Env:            env,
 		}
 
-		var contextInput string
+		var contentInput string
 
 		if state.Continuation != nil && state.Continuation.State != nil {
-			contextInput = state.Continuation.State.Input
+			contentInput = state.Continuation.State.Input
 		}
 
 		if state.ResumeInput != nil {
-			contextInput = *state.ResumeInput
+			contentInput = *state.ResumeInput
 		}
 
-		callCtx.InputContext, state, err = r.getContext(callCtx, state, monitor, env, contextInput)
-		if err != nil || state.InputContextContinuation != nil {
+		callCtx.InputContext, err = r.getContext(callCtx, state, monitor, env, contentInput)
+		if err != nil {
 			return state, err
 		}
 
@@ -772,10 +715,6 @@ func (r *Runner) subCalls(callCtx engine.Context, monitor Monitor, env []string,
 		callCtx.LastReturn = state.Continuation
 	}
 
-	if state.InputContextContinuation != nil {
-		return state, nil, nil
-	}
-
 	if state.SubCallID != "" {
 		if state.ResumeInput == nil {
 			return nil, nil, fmt.Errorf("invalid state, input must be set for sub call continuation on callID [%s]", state.SubCallID)

pkg/tests/runner_test.go

@@ -212,82 +212,8 @@ func TestContextSubChat(t *testing.T) {
 	prg, err := r.Load("")
 	require.NoError(t, err)
 
-	resp, err := r.Chat(context.Background(), nil, prg, os.Environ(), "User 1")
-	require.NoError(t, err)
-	r.AssertResponded(t)
-	assert.False(t, resp.Done)
-	autogold.Expect("Assistant Response 1 - from chatbot1").Equal(t, resp.Content)
-	autogold.ExpectFile(t, toJSONString(t, resp), autogold.Name(t.Name()+"/step1"))
-
-	r.RespondWith(tester.Result{
-		Content: []types.ContentPart{
-			{
-				ToolCall: &types.CompletionToolCall{
-					ID: "call_2",
-					Function: types.CompletionFunctionCall{
-						Name:      types.ToolNormalizer("sys.chat.finish"),
-						Arguments: "Response from context chatbot",
-					},
-				},
-			},
-		},
-	}, tester.Result{
-		Text: "Assistant Response 2 - from context tool",
-	}, tester.Result{
-		Text: "Assistant Response 3 - from main chat tool",
-	})
-	resp, err = r.Chat(context.Background(), resp.State, prg, os.Environ(), "User 2")
-	require.NoError(t, err)
-	r.AssertResponded(t)
-	assert.False(t, resp.Done)
-	autogold.Expect("Assistant Response 3 - from main chat tool").Equal(t, resp.Content)
-	autogold.ExpectFile(t, toJSONString(t, resp), autogold.Name(t.Name()+"/step2"))
-
-	r.RespondWith(tester.Result{
-		Content: []types.ContentPart{
-			{
-				ToolCall: &types.CompletionToolCall{
-					ID: "call_3",
-					Function: types.CompletionFunctionCall{
-						Name:      "chatbot",
-						Arguments: "Input to chatbot1 on resume",
-					},
-				},
-			},
-		},
-	}, tester.Result{
-		Text: "Assistant Response 4 - from chatbot1",
-	})
-	resp, err = r.Chat(context.Background(), resp.State, prg, os.Environ(), "User 3")
-	require.NoError(t, err)
-	r.AssertResponded(t)
-	assert.False(t, resp.Done)
-	autogold.Expect("Assistant Response 3 - from main chat tool").Equal(t, resp.Content)
-	autogold.ExpectFile(t, toJSONString(t, resp), autogold.Name(t.Name()+"/step3"))
-
-	r.RespondWith(tester.Result{
-		Content: []types.ContentPart{
-			{
-				ToolCall: &types.CompletionToolCall{
-					ID: "call_4",
-					Function: types.CompletionFunctionCall{
-						Name:      types.ToolNormalizer("sys.chat.finish"),
-						Arguments: "Response from context chatbot after resume",
-					},
-				},
-			},
-		},
-	}, tester.Result{
-		Text: "Assistant Response 5 - from context tool resume",
-	}, tester.Result{
-		Text: "Assistant Response 6 - from main chat tool resume",
-	})
-	resp, err = r.Chat(context.Background(), resp.State, prg, os.Environ(), "User 4")
-	require.NoError(t, err)
-	r.AssertResponded(t)
-	assert.False(t, resp.Done)
-	autogold.Expect("Assistant Response 6 - from main chat tool resume").Equal(t, resp.Content)
-	autogold.ExpectFile(t, toJSONString(t, resp), autogold.Name(t.Name()+"/step4"))
+	_, err = r.Chat(context.Background(), nil, prg, os.Environ(), "User 1")
+	autogold.Expect("invalid state: context tool [testdata/TestContextSubChat/test.gpt:subtool] can not result in a continuation").Equal(t, err.Error())
 }
 
 func TestSubChat(t *testing.T) {