Initialize onboarding agent scaffold

This commit is contained in:
dahyeon committed 2026-04-16 13:48:53 -07:00
commit 4294f3c92e
57 files changed
+14388

No files matched your search

+577
View File
@@ -0,0 +1,577 @@
import type { AgentRequest, AgentResponse, ConversationMessage } from "@agent/types";
import { getConversationSummaryKey } from "@conv/conversation-store";
import type { GarnetClient } from "@common/garnet";
import { getRequestLogger } from "@obs/context";
import type { LlmClient } from "@llm/llm-client";
import type { ChatMessage } from "@llm/types";
import type { RoomContextService } from "@room/room-context-service";
import type { Skill } from "@skills/skill";
import { PromptBuilder } from "./prompts/builder.js";
import {
getAcknowledgementMessage,
getAgeRequirementMessage,
getCompletedMessage,
getDiscordMessage,
getGreetingMessage,
getGenericHelpMessage,
getHeartGuideMessage,
getHeartLocationMessage,
getNicknameInvalidMessage,
getNicknameFormatMessage,
getPhotoFailedMessage,
getProgressMessage,
getRemainingStatusMessage,
getTimeoutWarningMessage,
} from "./onboarding-templates.js";
import { getOnboardingSessionKeyPrefix, getMaxResponseLength, getLlmTemperature } from "../../config.js";
import { OnboardingBlackboardStore } from "./state/blackboard.js";
import { deriveState } from "./state/derive.js";
import { OnboardingIntentClassifier } from "./state/classifier.js";
import type { DerivedState, Intent } from "./state/onboarding-state.js";
import type { OnboardingSession, PromptContext } from "./types.js";
const ALLOWED_URL_PATTERNS = [
/discord\.gg\/lolympus/u,
/open\.kakao\.com\/o\/gOscBAEh/u,
];
type LlmTextResult =
| { status: "success"; text: string }
| { status: "no_response" }
| { status: "failed" };
function postProcessResponse(text: string): string {
let processed = text.trim();
// Remove <think> blocks (Qwen thinking mode artifacts)
processed = processed.replace(/<think>[\s\S]*?<\/think>/gu, "").trim();
// Strip URLs not in allowlist
processed = processed.replace(
/https?:\/\/[^\s)}\]]+/gu,
(match) => {
if (ALLOWED_URL_PATTERNS.some((pattern) => pattern.test(match))) {
return match;
}
return "";
},
);
// Clean up double spaces from URL removal
processed = processed.replace(/ +/gu, " ").trim();
// Strip markdown formatting (KakaoTalk is plaintext)
processed = processed.replace(/\*\*(.+?)\*\*/gu, "$1"); // **bold**
processed = processed.replace(/\*(.+?)\*/gu, "$1"); // *italic*
processed = processed.replace(/__(.+?)__/gu, "$1"); // __underline__
processed = processed.replace(/~~(.+?)~~/gu, "$1"); // ~~strike~~
processed = processed.replace(/^#{1,6}\s+/gmu, ""); // ## headings
processed = processed.replace(/^[-*]\s+/gmu, ""); // - or * list items
processed = processed.replace(/`(.+?)`/gu, "$1"); // `inline code`
// Truncate to max length with Korean sentence boundary awareness
const maxLen = getMaxResponseLength();
if (processed.length > maxLen) {
processed = processed.slice(0, maxLen).trimEnd();
// Search backwards for a Korean sentence-ending pattern
const sentenceEndPattern = /(?:세요[.!]?|해요[.!]?|돼요[.!]?|어요[.!]?|아요[.!]?|거든요[.!]?|습니다[.!]?|됩니다[.!]?|니다[.!]?|요[.!]|다[.!]|[.!?])\s*$/u;
// Try progressively shorter substrings to find a sentence boundary
for (let i = processed.length; i > maxLen * 0.5; i--) {
const sub = processed.slice(0, i);
if (sentenceEndPattern.test(sub)) {
processed = sub;
break;
}
}
}
return processed.trim();
}
function isLowQualityResponse(
text: string,
options?: { allowShortResponse?: boolean },
): boolean {
if (!options?.allowShortResponse && text.length < 10) return true;
// Check for excessive repetition (same phrase 3+ times)
const words = text.split(/\s+/u);
if (words.length >= 6) {
const phrases = new Map<string, number>();
for (let i = 0; i < words.length - 1; i++) {
const bigram = `${words[i]} ${words[i + 1]}`;
phrases.set(bigram, (phrases.get(bigram) ?? 0) + 1);
}
for (const count of phrases.values()) {
if (count >= 3) return true;
}
}
return false;
}
export class OnboardingSkill implements Skill {
readonly name = "onboarding";
private readonly classifier: OnboardingIntentClassifier;
private readonly blackboardStore: OnboardingBlackboardStore;
constructor(
private readonly garnetClient: GarnetClient,
private readonly llmClient: LlmClient,
private readonly roomContextService?: RoomContextService,
) {
this.classifier = new OnboardingIntentClassifier(llmClient);
this.blackboardStore = new OnboardingBlackboardStore(garnetClient);
}
canHandle(request: AgentRequest): boolean {
return request.skill === "onboarding";
}
async handle(
request: AgentRequest,
conversationHistory: ConversationMessage[],
): Promise<AgentResponse> {
const logger = getRequestLogger();
const session = await this.loadSession(
request.chatroomId,
request.userId,
);
if (request.trigger === "user-message" && !request.userMessage?.trim()) {
return this.makeEmptyResponse(request.requestId);
}
const classified = await this.classifier.classify(
request.userMessage,
request.trigger,
);
const derived = deriveState(session, request.trigger, classified.intent);
if (!derived.shouldRespond) {
return this.makeEmptyResponse(request.requestId);
}
let response: AgentResponse;
if (derived.responseMode === "template") {
response = this.makeTemplateFallbackResponse(
request,
session,
derived.intent,
derived,
);
} else {
const llmResult = await this.handleLlm(
request,
session,
conversationHistory,
derived,
);
if (llmResult.status === "success") {
response = this.makeLlmResponse(request.requestId, llmResult.text);
} else if (llmResult.status === "no_response") {
response = this.makeEmptyResponse(request.requestId);
} else {
response = this.makeTemplateFallbackResponse(
request,
session,
derived.intent,
derived,
);
}
}
if (response.text.trim()) {
await this.rememberTurn(request, derived).catch((error) => {
logger.warn({ err: error }, "[OnboardingSkill] Failed to update blackboard");
});
}
return response;
}
private async loadSession(
chatroomId: string,
userId: string,
): Promise<OnboardingSession | null> {
const prefix = getOnboardingSessionKeyPrefix();
const key = `${prefix}:onboarding:${chatroomId}:${userId}`;
return this.garnetClient.getJson<OnboardingSession>(key);
}
private async handleLlm(
request: AgentRequest,
session: OnboardingSession | null,
conversationHistory: ConversationMessage[],
derived: DerivedState,
): Promise<LlmTextResult> {
const messages = await this.buildLlmMessages(
request,
session,
conversationHistory,
derived,
);
return this.generateLlmText(messages, {
allowShortResponse: derived.allowShortResponse,
maxTokens: derived.suggestedMaxTokens,
retryOnLowQuality:
request.trigger === "user-message" && !derived.allowShortResponse,
});
}
private async buildLlmMessages(
request: AgentRequest,
session: OnboardingSession | null,
conversationHistory: ConversationMessage[],
derived: DerivedState,
): Promise<ChatMessage[]> {
const logger = getRequestLogger();
const roomContextPromise =
request.trigger === "user-message" && this.roomContextService
? this.roomContextService
.getRecentMessages(request.chatroomId)
.catch((error) => {
logger.warn({ err: error }, "[OnboardingSkill] Failed to fetch room context");
return undefined;
})
: Promise.resolve(undefined);
const [blackboard, summary, roomContext] = await Promise.all([
this.blackboardStore.load(request.chatroomId, request.userId),
this.loadConversationSummary(request.chatroomId, request.userId),
roomContextPromise,
]);
const context: PromptContext = {
blackboard,
conversationHistory,
roomContext,
summary,
userMessage: this.buildPromptUserMessage(request, derived),
};
return PromptBuilder.forDerived(derived, session, context).build();
}
private buildPromptUserMessage(
request: AgentRequest,
derived: DerivedState,
): string {
switch (request.trigger) {
case "nickname-invalid":
return `현재 닉네임은 "${request.nickname}"예요. 왜 안 되는지와 어디를 고치면 되는지만 알려줘.`;
case "photo-failed":
return "하트 인증 사진이 실패했어요. 다시 시도할 수 있게 필요한 내용만 안내해줘.";
case "progress-update":
return "현재 새내기 등록 진행상황만 짧게 알려줘.";
case "timeout-warning":
return "등록 마감이 가까워졌어요. 남은 절차만 짧고 따뜻하게 안내해줘.";
case "completed":
return "새내기 등록을 모두 마친 유저에게 짧고 따뜻하게 축하 인사를 해줘.";
case "user-message":
if (derived.intent.kind === "status-question") {
return "현재 남은 절차나 완료 상태만 1문장으로 아주 짧게 알려줘.";
}
return request.userMessage?.trim() || "지금 필요한 온보딩 안내만 도와줘.";
default:
return "지금 필요한 온보딩 안내만 짧게 도와줘.";
}
}
private async loadConversationSummary(
chatroomId: string,
userId: string,
): Promise<string | undefined> {
const key = getConversationSummaryKey(chatroomId, userId);
return (await this.garnetClient.getString(key)) ?? undefined;
}
private async rememberTurn(
request: AgentRequest,
derived: DerivedState,
): Promise<void> {
const now = new Date().toISOString();
const userMessage = request.userMessage?.trim();
await this.blackboardStore.update(
request.chatroomId,
request.userId,
(current) => {
const openQuestions =
userMessage &&
(
derived.intent.kind === "help-how" ||
derived.intent.kind === "help-where" ||
derived.intent.kind === "nickname-question" ||
derived.intent.kind === "photo-question" ||
derived.intent.kind === "discord-question"
)
? [...current.openQuestions, userMessage].slice(-3)
: current.openQuestions;
const recentNicknameAttempts =
request.trigger === "nickname-invalid" ||
derived.intent.kind === "nickname-question"
? Array.from(
new Set([
...current.recentNicknameAttempts,
request.nickname,
]),
).slice(-5)
: current.recentNicknameAttempts;
return {
...current,
flaggedIssues:
derived.phase.kind === "nickname-rejected"
? derived.phase.issues.map((issue) => issue.message)
: derived.phase.kind === "completed"
? []
: current.flaggedIssues,
lastIntent: derived.intent.kind,
lastIntentAt: now,
openQuestions:
derived.phase.kind === "completed" ? [] : openQuestions,
recentNicknameAttempts,
toneMemory: {
...current.toneMemory,
greetedAt:
derived.intent.kind === "greeting"
? now
: current.toneMemory.greetedAt,
thankedAt:
derived.intent.kind === "acknowledgement"
? now
: current.toneMemory.thankedAt,
},
};
},
);
}
private makeTemplateFallbackResponse(
request: AgentRequest,
session: OnboardingSession | null,
intent: Intent,
derived: DerivedState,
): AgentResponse {
switch (request.trigger) {
case "new-member":
return this.makeEmptyResponse(request.requestId);
case "nickname-invalid":
return this.makeTemplateResponse(
request.requestId,
getNicknameInvalidMessage(request.nickname, session),
);
case "photo-failed":
return this.makeTemplateResponse(
request.requestId,
getPhotoFailedMessage(request.nickname),
);
case "progress-update":
return this.makeTemplateResponse(
request.requestId,
session
? getProgressMessage(request.nickname, session)
: getGenericHelpMessage(request.nickname, session),
);
case "timeout-warning":
return this.makeTemplateResponse(
request.requestId,
getTimeoutWarningMessage(request.nickname),
);
case "completed":
return this.makeTemplateResponse(
request.requestId,
getCompletedMessage(request.nickname),
);
default:
return this.makeTemplateResponse(
request.requestId,
this.getIntentFallbackText(request.nickname, session, intent, derived),
);
}
}
private getIntentFallbackText(
nickname: string,
session: OnboardingSession | null,
intent: Intent,
derived: DerivedState,
): string {
switch (intent.kind) {
case "greeting":
return getGreetingMessage();
case "acknowledgement":
return getAcknowledgementMessage();
case "status-question":
return getRemainingStatusMessage(session);
case "nickname-question":
return derived.phase.kind === "nickname-rejected"
? getNicknameInvalidMessage(nickname, session)
: getNicknameFormatMessage();
case "photo-question":
return derived.phase.kind === "photo-rejected"
? getPhotoFailedMessage(nickname)
: getHeartGuideMessage();
case "help-where":
if (
derived.phase.kind === "photo-pending" ||
derived.phase.kind === "photo-rejected" ||
(derived.phase.kind === "deadline-near" &&
derived.phase.remaining.includes("photo"))
) {
return getHeartLocationMessage();
}
return getGenericHelpMessage(nickname, session);
case "help-how":
if (
derived.phase.kind === "nickname-pending" ||
derived.phase.kind === "nickname-rejected" ||
(derived.phase.kind === "deadline-near" &&
derived.phase.remaining.includes("nickname"))
) {
return getNicknameFormatMessage();
}
if (
derived.phase.kind === "photo-pending" ||
derived.phase.kind === "photo-rejected" ||
(derived.phase.kind === "deadline-near" &&
derived.phase.remaining.includes("photo"))
) {
return getHeartGuideMessage();
}
return getGenericHelpMessage(nickname, session);
case "discord-question":
return getDiscordMessage(nickname, session);
case "age-question":
return getAgeRequirementMessage();
case "chitchat":
case "off-topic-to-other":
return "";
case "unknown":
return getGenericHelpMessage(nickname, session);
}
}
private async generateLlmText(
messages: ChatMessage[],
options?: {
allowShortResponse?: boolean;
maxTokens?: number;
retryOnLowQuality?: boolean;
temperature?: number;
},
): Promise<LlmTextResult> {
if (!this.llmClient.hasEndpoints()) {
return { status: "failed" };
}
const attempts: Array<{
maxTokens?: number;
temperature?: number;
}> = [];
const firstAttempt: {
maxTokens?: number;
temperature?: number;
} = {};
if (options?.maxTokens !== undefined) {
firstAttempt.maxTokens = options.maxTokens;
}
if (options?.temperature !== undefined) {
firstAttempt.temperature = options.temperature;
}
attempts.push(firstAttempt);
if (options?.retryOnLowQuality) {
const retryAttempt: {
maxTokens?: number;
temperature?: number;
} = {
temperature: getLlmTemperature() + 0.1,
};
if (options.maxTokens !== undefined) {
retryAttempt.maxTokens = options.maxTokens;
}
attempts.push(retryAttempt);
}
for (const attempt of attempts) {
const requestOptions: {
maxTokens?: number;
temperature?: number;
} = {};
if (attempt.maxTokens !== undefined) {
requestOptions.maxTokens = attempt.maxTokens;
}
if (attempt.temperature !== undefined) {
requestOptions.temperature = attempt.temperature;
}
const llmResult = await this.llmClient.chatCompletion(
messages,
requestOptions,
);
if (!llmResult) {
continue;
}
const processed = postProcessResponse(llmResult.content);
if (!processed) {
continue;
}
if (processed.includes("[NO_RESPONSE]")) {
return { status: "no_response" };
}
const qualityOptions =
options?.allowShortResponse !== undefined
? { allowShortResponse: options.allowShortResponse }
: undefined;
if (isLowQualityResponse(processed, qualityOptions)) {
continue;
}
return {
status: "success",
text: processed,
};
}
return { status: "failed" };
}
private makeTemplateResponse(
requestId: string,
text: string,
): AgentResponse {
return {
requestId,
text,
confidence: 0.8,
source: "template",
};
}
private makeLlmResponse(
requestId: string,
text: string,
): AgentResponse {
return {
requestId,
text,
confidence: 0.9,
source: "llm",
};
}
private makeEmptyResponse(requestId: string): AgentResponse {
return {
requestId,
text: "",
confidence: 0,
source: "template",
};
}
}