AutoGen

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def web_search(query: str) -> str:
  """가짜 웹 검색."""
  return f"results for {query}"

model_client = OpenAIChatCompletionClient(model="gpt-4o")

researcher = AssistantAgent(
  name="researcher",
  model_client=model_client,
  tools=[web_search],
  system_message="너는 시니어 리서처다. 출처 없는 주장은 하지 않는다.",
  reflect_on_tool_use=True,
)

// TypeScript에는 공식 AutoGen v0.4 SDK가 없다. 액터-메시지 패턴을 직접 구현한다.
type Message = { from: string; to?: string; content: string }

export abstract class Agent {
constructor(public name: string) {}
abstract handle(msg: Message): Promise<Message[]>
}

export class AssistantAgent extends Agent {
constructor(
  name: string,
  private systemMessage: string,
  private llm: (msgs: Message[]) => Promise<string>,
  private tools: Record<string, (args: any) => Promise<string>> = {},
) { super(name) }

async handle(msg: Message): Promise<Message[]> {
  const reply = await this.llm([
    { from: 'system', content: this.systemMessage },
    msg,
  ])
  return [{ from: this.name, content: reply }]
}
}

from autogen_agentchat.agents import UserProxyAgent
from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor

# 사람 입력을 받는 모드
human = UserProxyAgent(
  name="human",
  input_func=input,  # CLI 입력
)

# 코드 실행기 모드 — 다른 에이전트의 코드 블록을 자동 실행
executor = UserProxyAgent(
  name="executor",
  code_executor=DockerCommandLineCodeExecutor(work_dir="/tmp/run"),
)

export class UserProxyAgent extends Agent {
constructor(
  name: string,
  private mode: 'human' | 'executor',
  private readInput?: () => Promise<string>,
  private exec?: (code: string) => Promise<string>,
) { super(name) }

async handle(msg: Message): Promise<Message[]> {
  if (this.mode === 'human' && this.readInput) {
    const text = await this.readInput()
    return [{ from: this.name, content: text }]
  }
  if (this.mode === 'executor' && this.exec) {
    const code = extractCodeBlock(msg.content)
    const out = code ? await this.exec(code) : '(no code)'
    return [{ from: this.name, content: out }]
  }
  return []
}
}
function extractCodeBlock(s: string): string | null {
const m = s.match(/```(?:python)?\n([\s\S]*?)\n```/)
return m?.[1] ?? null
}

from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import TextMentionTermination

# 종료 조건 — 누군가 "APPROVE"를 말하면 끝
termination = TextMentionTermination("APPROVE")

team = RoundRobinGroupChat(
  [researcher, critic],
  termination_condition=termination,
)

result = await team.run(task="A2A 프로토콜에 대해 한 단락 정리해 보자.")
print(result.messages[-1].content)

type Termination = (history: Message[]) => boolean

export class RoundRobinGroupChat {
constructor(
  private agents: Agent[],
  private terminate: Termination,
) {}

async run(task: string): Promise<Message[]> {
  const history: Message[] = [{ from: 'user', content: task }]
  let i = 0
  while (!this.terminate(history)) {
    const speaker = this.agents[i % this.agents.length]
    const replies = await speaker.handle(history[history.length - 1])
    history.push(...replies)
    i += 1
  }
  return history
}
}

const textMentionTermination = (needle: string): Termination =>
(h) => h.some((m) => m.content.includes(needle))

from autogen_agentchat.teams import SelectorGroupChat

selector_prompt = """다음 대화에서 가장 어울리는 다음 발화자를 골라라.
{roles}
{history}
지금 차례를 가질 한 명의 이름만 출력."""

team = SelectorGroupChat(
  [researcher, writer, critic],
  model_client=model_client,
  selector_prompt=selector_prompt,
  termination_condition=termination,
)

// LLM 기반 셀렉터의 미니 구현
export class SelectorGroupChat {
constructor(
  private agents: Agent[],
  private selectNext: (history: Message[], roster: Agent[]) => Promise<Agent>,
  private terminate: Termination,
) {}

async run(task: string): Promise<Message[]> {
  const history: Message[] = [{ from: 'user', content: task }]
  while (!this.terminate(history)) {
    const speaker = await this.selectNext(history, this.agents)
    const replies = await speaker.handle(history[history.length - 1])
    history.push(...replies)
  }
  return history
}
}

from autogen_agentchat.conditions import (
  MaxMessageTermination,
  TextMentionTermination,
  ExternalTermination,
)

stop = (
  TextMentionTermination("APPROVE")
  | MaxMessageTermination(max_messages=12)
)

ext = ExternalTermination()
team = RoundRobinGroupChat([a, b], termination_condition=stop | ext)
# 어디서든 ext.set() 호출하면 즉시 중단

const maxMessages = (n: number): Termination => (h) => h.length >= n
const orT = (...ts: Termination[]): Termination =>
(h) => ts.some((t) => t(h))

const stop = orT(
textMentionTermination('APPROVE'),
maxMessages(12),
)

# 끝까지 한 번에
result = await team.run(task="요약해 줘")

# 메시지 단위 스트림
async for msg in team.run_stream(task="요약해 줘"):
  print(msg.source, ":", msg.content)

# 중단했다가 이어 가기
await team.reset()                # 상태 초기화
await team.run(task="다른 주제")  # 처음부터
# 또는 task 없이 호출 → 직전 대화에 이어 발화

// 두 API를 같이 노출
export class Team {
constructor(public chat: RoundRobinGroupChat | SelectorGroupChat) {}
run(task: string) { return this.chat.run(task) }
async *runStream(task: string) {
  for (const m of await this.chat.run(task)) yield m
}
}