02ChatModelAgent 与 Runner

// TypedChatModelAgentConfig is the generic configuration for ChatModelAgent.
type TypedChatModelAgentConfig[M MessageType] struct {
  // Name of the agent. Better be unique across all agents.
  // Optional. If empty, the agent can still run standalone but cannot be used as
  // a sub-agent tool via NewAgentTool (which requires a non-empty Name).
  Name string
  // Description of the agent's capabilities.
  // Helps other agents determine whether to transfer tasks to this agent.
  // Optional. If empty, the agent can still run standalone but cannot be used as
  // a sub-agent tool via NewAgentTool (which requires a non-empty Description).
  Description string
  // Instruction used as the system prompt for this agent.
  // Optional. If empty, no system prompt will be used.
  // Supports f-string placeholders for session values in default GenModelInput, for example:
  // "You are a helpful assistant. The current time is {Time}. The current user is {User}."
  // These placeholders will be replaced with session values for "Time" and "User".
  Instruction string

  // Model is the chat model used by the agent.
  // If your ChatModelAgent uses any tools, this model must support the model.WithTools
  // call option, as that's how ChatModelAgent configures the model with tool information.
  Model model.BaseModel[M]

  ToolsConfig ToolsConfig

  // GenModelInput transforms instructions and input messages into the model's input format.
  // Optional. Defaults to defaultGenModelInput which combines instruction and messages.
  GenModelInput TypedGenModelInput[M]

  // Exit defines the tool used to terminate the agent process.
  // Optional. If nil, no Exit Action will be generated.
  // You can use the provided 'ExitTool' implementation directly.
  //
  // NOT RECOMMENDED: Agent transfer with full context sharing between agents has not proven
  // to be more effective empirically. Consider using ChatModelAgent with AgentTool
  // or DeepAgent instead for most multi-agent scenarios.
  Exit tool.BaseTool

  // OutputKey stores the agent's response in the session.
  // Optional. When set, stores output via AddSessionValue(ctx, outputKey, msg.Content).
  //
  // NOT RECOMMENDED: Agent transfer with full context sharing between agents has not proven
  // to be more effective empirically. Consider using ChatModelAgent with AgentTool
  // or DeepAgent instead for most multi-agent scenarios.
  OutputKey string

  // MaxIterations defines the upper limit of ChatModel generation cycles.
  // The agent will terminate with an error if this limit is exceeded.
// … 省略 109 行；完整声明 L259–415，点击上方「浏览完整文件」

// NewChatModelAgent creates a new ChatModelAgent with the given config.
func NewChatModelAgent(ctx context.Context, config *ChatModelAgentConfig) (*ChatModelAgent, error) {
  return NewTypedChatModelAgent[*schema.Message](ctx, config)
}

func (r *TypedRunner[M]) Query(ctx context.Context, query string,
    opts ...AgentRunOption) *AsyncIterator[*TypedAgentEvent[M]] {
    msgs, err := newUserMessage[M](query)
    if err != nil {
        return errorIterator[M](err)
    }
    return r.Run(ctx, []M{msgs}, opts...)
}

func (r *TypedRunner[M]) Run(ctx context.Context, messages []M,
  opts ...AgentRunOption) *AsyncIterator[*TypedAgentEvent[M]] {
  return typedRunnerRunImpl(r.a, r.enableStreaming, r.store, ctx, messages, opts...)
}

type AsyncIterator[T any] struct {
  ch *internal.UnboundedChan[T]
}

func (ai *AsyncIterator[T]) Next() (T, bool) {
  return ai.ch.Receive()
}

// GetMessage extracts the Message from an AgentEvent. For streaming output,
// it duplicates the stream and concatenates it into a single Message.
func GetMessage(e *AgentEvent) (Message, *AgentEvent, error) {
  return TypedGetMessage(e)
}

if mp.input.EnableStreaming {
    msgStream, err_ = runnable.Stream(ctx, in, runOpts...)
} else {
    msg, err_ = runnable.Invoke(ctx, in, runOpts...)
}

type TypedRunnerConfig[M MessageType] struct {
  Agent           TypedAgent[M]
  EnableStreaming bool

  CheckPointStore CheckPointStore
}

// Resume continues an interrupted execution from a checkpoint, using an "Implicit Resume All" strategy.
// This method is best for simpler use cases where the act of resuming implies that all previously
// interrupted points should proceed without specific data.
//
// When using this method, all interrupted agents will receive `isResumeFlow = false` when they
// call `GetResumeContext`, as no specific agent was targeted. This is suitable for the "Simple Confirmation"
// pattern where an agent only needs to know `wasInterrupted` is true to continue.
func (r *TypedRunner[M]) Resume(ctx context.Context, checkPointID string, opts ...AgentRunOption) (
  *AsyncIterator[*TypedAgentEvent[M]], error) {
  return r.resumeInternal(ctx, checkPointID, nil, opts...)
}