코드처럼 동작하는 AI 서비스 구축을 위한 시스템 프롬프트 가이드

class GroupChatManager {
    protected history: Message[] = [];
    protected agents: Map<string, ConversableAgent> = new Map();

    protected async processMessage(message: Message): Promise<Message> {
        this.history.push(message);

        if (this.shouldEndConversation(message, this.history)) {
            return message;
        }

        const currentAgent = this.agents.get(message.receiver);
        if (!currentAgent) {
            throw new Error(`Agent ${message.receiver} not found`);
        }

        const fullPrompt = await this.contextStrategy(this.history, message);
        const responseMessage = await currentAgent.answer({
            sender: message.sender,
            receiver: currentAgent.name,
            content: fullPrompt,
        }, this.history);

        return this.processMessage(responseMessage);
    }
}

abstract class ConversableAgent {
    abstract readonly name: string;
    protected manager!: GroupChatManager;

    async answer(message: Message, history: Message[]): Promise<Message> {
        const { content, nextReceiver } = await this.processAnswer(message, history);
        return {
            sender: this.name,
            receiver: nextReceiver,
            content,
        };
    }

    protected abstract processAnswer(message: Message, history: Message[]): Promise<{ content: string; nextReceiver: string; }>;
}

export class UserProxy extends ConversableAgent {
    readonly name = "user";
    private resolveInput: ((value: string) => void) | null = null;
    private _isMyTurn: boolean = true;

    async processAnswer(message: Message): Promise<{ content: string; nextReceiver: string; }> {
        this.manager.resetTurns();
        this.setTurn(true);
        return new Promise<{ content: string; nextReceiver: string; }>((resolve) => {
            this.resolveInput = (input: string) => {
                this.setTurn(false);
                resolve({
                    content: input,
                    nextReceiver: "dialogue"
                });
            };
        });
    }

    handleInput(input: string) {
        if (this.resolveInput && this._isMyTurn) {
            this.resolveInput(input);
            this.resolveInput = null;
        }
    }
}

export const ChatInterface = () => {
    const [isUserTurn, setIsUserTurn] = React.useState(true);
    const [input, setInput] = React.useState("");

    // UserProxy의 턴 변경 감지
    React.useEffect(() => {
        const unsubscribe = userAgent.onTurnChanged((isMyTurn) => {
            setIsUserTurn(isMyTurn);
        });
        return () => unsubscribe();
    }, []);

    // 사용자 입력 처리
    const handleSubmit = async (e: React.SyntheticEvent) => {
        e.preventDefault();
        if (!input.trim() || !isUserTurn) return;

        const userMessage: Message = {
            sender: "user",
            receiver: "dialogue",
            content: input,
        };

        setInput("");

        if (isFirst.current) {
            isFirst.current = false;
            await groupChatManager.chatStart(userMessage);
        } else {
            userAgent.handleInput(input);
        }
    };

    return (
        <form onSubmit={handleSubmit}>
            <textarea
                value={input}
                onChange={(e) => setInput(e.target.value)}
                placeholder={isUserTurn ? "메시지를 입력하세요..." : "AI가 응답하는 중입니다..."}
                disabled={!isUserTurn}
            />
            <Button
                type="submit"
                disabled={!isUserTurn || !input.trim()}
            >
                전송
            </Button>
        </form>
    );
};