05中断与人在回路（先会用）

/*
 * Copyright 2025 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package adk

import (
  "bytes"
  "context"
  "encoding/gob"
  "errors"
  "fmt"
  "sync"

  "github.com/cloudwego/eino/internal/core"
  "github.com/cloudwego/eino/schema"
)

// ResumeInfo holds all the information necessary to resume an interrupted agent execution.
// It is created by the framework and passed to an agent's Resume method.
type ResumeInfo struct {
  // EnableStreaming indicates whether the original execution was in streaming mode.
  EnableStreaming bool

  // Deprecated: use InterruptContexts from the embedded InterruptInfo for user-facing details,
  // and GetInterruptState for internal state retrieval.
  *InterruptInfo
// … 这只是文件开头 39 行，并非完整声明；点击上方「浏览完整文件」

// TypedInterrupt creates a typed interrupt event that pauses execution to request external input.
// It is the generic counterpart of Interrupt; see Interrupt for full documentation.
func TypedInterrupt[M MessageType](ctx context.Context, info any) *TypedAgentEvent[M] {
  var rp []RunStep
  rCtx := getRunCtx(ctx)
  if rCtx != nil {
    rp = rCtx.RunPath
  }

  is, err := core.Interrupt(ctx, info, nil, nil,
    core.WithLayerPayload(rp))
  if err != nil {
    return &TypedAgentEvent[M]{Err: err}
  }

  contexts := core.ToInterruptContexts(is, allowedAddressSegmentTypes)

  return &TypedAgentEvent[M]{
    Action: &AgentAction{
      Interrupted: &InterruptInfo{
        InterruptContexts: contexts,
      },
      internalInterrupted: is,
    },
  }
}

func newBridgeStore() *bridgeStore {
  return &bridgeStore{data: make(map[string][]byte)}
}

/*
 * Copyright 2025 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package adk

import (
  "context"
  "errors"
  "fmt"
  "runtime/debug"
  "sync"

  "github.com/cloudwego/eino/internal/core"
  "github.com/cloudwego/eino/internal/safe"
  "github.com/cloudwego/eino/schema"
)

func errorIterator[M MessageType](err error) *AsyncIterator[*TypedAgentEvent[M]] {
  iter, gen := NewAsyncIteratorPair[*TypedAgentEvent[M]]()
  gen.Send(&TypedAgentEvent[M]{Err: err})
  gen.Close()
  return iter
}

func newUserMessage[M MessageType](query string) (M, error) {
  var zero M
  switch any(zero).(type) {
// … 这只是文件开头 40 行，并非完整声明；点击上方「浏览完整文件」

// 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...)
}

// ResumeWithParams continues an interrupted execution from a checkpoint with specific parameters.
// This is the most common and powerful way to resume, allowing you to target specific interrupt points
// (identified by their address/ID) and provide them with data.
//
// The params.Targets map should contain the addresses of the components to be resumed as keys. These addresses
// can point to any interruptible component in the entire execution graph, including ADK agents, compose
// graph nodes, or tools. The value can be the resume data for that component, or `nil` if no data is needed.
//
// When using this method:
//   - Components whose addresses are in the params.Targets map will receive `isResumeFlow = true` when they
//     call `GetResumeContext`.
//   - Interrupted components whose addresses are NOT in the params.Targets map must decide how to proceed:
//     -- "Leaf" components (the actual root causes of the original interrupt) MUST re-interrupt themselves
//     to preserve their state.
//     -- "Composite" agents (like SequentialAgent or ChatModelAgent) should generally proceed with their
//     execution. They act as conduits, allowing the resume signal to flow to their children. They will
//     naturally re-interrupt if one of their interrupted children re-interrupts, as they receive the
//     new `CompositeInterrupt` signal from them.
func (r *TypedRunner[M]) ResumeWithParams(ctx context.Context, checkPointID string, params *ResumeParams, opts ...AgentRunOption) (*AsyncIterator[*TypedAgentEvent[M]], error) {
  return r.resumeInternal(ctx, checkPointID, params.Targets, opts...)
}