Passing output of one agent to another in a background job

[frgorczyca]

Hey I'm currently implementing a use case where an Agent uses a StructuredOutput, returns a 200 OK back to the client and starts a background job using the output parameters. This background job has a new parallel agent that utilizes the StructuredOutput the previous agent as InputSchema. A simplified snippet:

planLLMSchema = &genai.Schema{
        // genai type definition
}

func postEndpoint () {
        planAgent, err := llmagent.New(llmagent.Config{
                Name:         "plan_agent",
                Model:        model,
                Description:  "Creates some plan.",
                Instruction:  planPrompt,
                OutputKey:    "generated_plan",
                OutputSchema: planLLMSchema,
        })

        // wrapper for runner.Run(), returns LLMResponse.Content
        llmPlanOutput, err := adkService.CallAgent(
	        r.Context(),
	        planAgent,
	        activeSession,
	        prompt
        )

        var typedPlan Plan
        typedPlan := convertLLMToPlan(llmPlanOutput)
        if err != nil {
                return err
        } 

        for i, step := range typedPlan.steps {
                plan.jobId := uuid.NewString()
        }
        
        // Run this as non-blocking
        startBackgroundJob(typedPlan)

        return typedPlan 
}

type Plan struct {
        // regular go type definitions
}

func startBackgroundJob(typedPlan Plan) error {
        agents := []agent.Agent{} 

        for i, step := range typedPlan.steps {
                backgroundAgent, err := llmagent.New(llmagent.Config{
                        Name:        "background_job_agent",
                        Model:       model,
                        Description: "Executes the plan step",
                        Instruction: step.backgroundJobInstruction,
                        OutputKey: step.jobId
                })

                agents = append(agents, academicAgent)
        }

        parallelAgent, err := parallelagent.New(parallelagent.Config{
		AgentConfig: agent.Config{
			Name:        name,
			Description: "Run plan in parallel",
			SubAgents:   agents,
		},
	})

        // run parallel agent
}

I'm looking to preserve the ids of the jobs, so the output can be accessed later. Is there a more idiomatic way to do this nonblocking call (e.g. through some agent pattern) that still preserves the unique ID of jobs so I am able to distinguish the outputs?