Tune LLM routing and prompts

This commit is contained in:
dahyeon committed 2026-04-21 15:24:21 -07:00
1 parent 9c013f7d4f
commit 60f33b8f4b
19 files changed
+736 -803

No files matched your search

+11 -11
View File
@@ -163,8 +163,7 @@ export function getDeadlineNearThresholdMin(): number {
} }
export function getOpenRouterEnabled(): boolean { export function getOpenRouterEnabled(): boolean {
const value = process.env["OPENROUTER_ENABLED"]?.trim().toLowerCase(); return Boolean(process.env["OPENROUTER_API_KEY"]?.trim());
return value === "1" || value === "true" || value === "yes";
} }
export function getOpenRouterApiUrl(): string { export function getOpenRouterApiUrl(): string {
@@ -203,15 +202,16 @@ export function getTier2CriticModel(): string {
); );
} }
export function getOpenRouterTier1Model(): string { export function getOpenRouterModels(): string[] {
return ( const raw = process.env["OPENROUTER_MODEL"]?.trim();
process.env["OPENROUTER_TIER1_MODEL"]?.trim() || if (!raw) {
"openai/gpt-5.3-codex-spark" return ["openai/gpt-5.3-codex-spark"];
); }
} const models = raw
.split(",")
export function getOpenRouterTier2Model(): string { .map((value) => value.trim())
return process.env["OPENROUTER_TIER2_MODEL"]?.trim() || "openai/gpt-5.4"; .filter((value) => value.length > 0);
return models.length > 0 ? models : ["openai/gpt-5.3-codex-spark"];
} }
export function getLlmMaxTokens(): number { export function getLlmMaxTokens(): number {
+4 -3
View File
@@ -22,7 +22,7 @@ import type {
DerivedState, DerivedState,
} from "@skills/onboarding/state/onboarding-state"; } from "@skills/onboarding/state/onboarding-state";
import { noopShadowEvalPublisher } from "./shadow-bus.js"; import { noopShadowEvalPublisher } from "./shadow-bus.js";
import { getOnboardingSessionKeyPrefix, getOpenRouterApiUrl, getOpenRouterEnabled } from "../config.js"; import { getOnboardingSessionKeyPrefix, getOpenRouterApiUrl } from "../config.js";
import { judgeOnboardingWithLlm } from "./judges/llm-judge.js"; import { judgeOnboardingWithLlm } from "./judges/llm-judge.js";
import { judgeOnboardingRuleCase } from "./judges/rule-judge.js"; import { judgeOnboardingRuleCase } from "./judges/rule-judge.js";
import type { import type {
@@ -188,7 +188,8 @@ function createEvalLlmClient(): LlmClient {
process.env["AGENT_LLM_API_URLS"], process.env["AGENT_LLM_API_URLS"],
process.env["LLAMA_SERVER_API_URL"], process.env["LLAMA_SERVER_API_URL"],
); );
const openRouterEndpoints = getOpenRouterEnabled() const openRouterApiKey = firstNonEmpty(process.env["OPENROUTER_API_KEY"]);
const openRouterEndpoints = openRouterApiKey
? parseEndpointList(process.env["OPENROUTER_API_URL"], getOpenRouterApiUrl()) ? parseEndpointList(process.env["OPENROUTER_API_URL"], getOpenRouterApiUrl())
: []; : [];
@@ -200,7 +201,7 @@ function createEvalLlmClient(): LlmClient {
[ [
["cliproxy", firstNonEmpty(process.env["CLI_PROXY_API_KEY"])], ["cliproxy", firstNonEmpty(process.env["CLI_PROXY_API_KEY"])],
["llama", llmApiKey], ["llama", llmApiKey],
["openrouter", firstNonEmpty(process.env["OPENROUTER_API_KEY"])], ["openrouter", openRouterApiKey],
].filter((entry): entry is [string, string] => typeof entry[1] === "string"), ].filter((entry): entry is [string, string] => typeof entry[1] === "string"),
) as Partial<Record<ProviderName, string>>; ) as Partial<Record<ProviderName, string>>;
+84 -76
View File
@@ -16,7 +16,7 @@ import {
} from "../config.js"; } from "../config.js";
import { LlmCircuitBreaker } from "./circuit.js"; import { LlmCircuitBreaker } from "./circuit.js";
import { getProviderAdapter } from "./providers/index.js"; import { getProviderAdapter } from "./providers/index.js";
import { selectMaxTokensForTier, selectModelForProvider, selectProviderOrder } from "./routing.js"; import { selectMaxTokensForTier, selectModelsForProvider, selectProviderOrder } from "./routing.js";
const DEFAULT_MODEL = "Qwen3.5-4B"; const DEFAULT_MODEL = "Qwen3.5-4B";
@@ -157,91 +157,99 @@ export class LlmClient {
continue; continue;
} }
try { const requestTimeoutMs = Math.max(
const requestTimeoutMs = Math.max( 1,
1, Math.min(getLlmRequestTimeoutMs(), options?.deadlineMs ?? Number.POSITIVE_INFINITY),
Math.min(getLlmRequestTimeoutMs(), options?.deadlineMs ?? Number.POSITIVE_INFINITY), );
); const models = selectModelsForProvider(provider.name, options, this.llamaModel);
const request = provider.prepareRequest({ let endpointSucceeded = false;
jsonMode: options?.jsonMode,
maxTokens: selectMaxTokensForTier(options),
messages,
model: selectModelForProvider(provider.name, options, this.llamaModel),
temperature: options?.temperature ?? getLlmTemperature(),
tools: options?.tools,
});
const llmResult = await withLlmSpan( for (const model of models) {
{ try {
"gen_ai.request.model": request.model, const request = provider.prepareRequest({
"gen_ai.system": provider.name, jsonMode: options?.jsonMode,
}, maxTokens: selectMaxTokensForTier(options),
async (span) => { messages,
const response = await fetch(endpoint.completionUrl, { model,
body: JSON.stringify(request), temperature: options?.temperature ?? getLlmTemperature(),
headers: this.getHeaders(provider.name, true), tools: options?.tools,
method: "POST", });
signal: getRequestSignal(requestTimeoutMs, options?.signal),
});
if (!response.ok) { const llmResult = await withLlmSpan(
const body = (await response.text()).slice(0, 500); {
logger.warn( "gen_ai.request.model": request.model,
{ "gen_ai.system": provider.name,
endpoint: endpoint.completionUrl, },
provider: provider.name, async (span) => {
status: response.status, const response = await fetch(endpoint.completionUrl, {
body, body: JSON.stringify(request),
}, headers: this.getHeaders(provider.name, true),
"[LLM] Request failed", method: "POST",
); signal: getRequestSignal(requestTimeoutMs, options?.signal),
return null; });
}
const payload = (await response.json()) as ChatCompletionResponse; if (!response.ok) {
const result = provider.toResult(payload, endpoint.completionUrl); const body = (await response.text()).slice(0, 500);
logger.warn(
{
endpoint: endpoint.completionUrl,
provider: provider.name,
model: request.model,
status: response.status,
body,
},
"[LLM] Request failed",
);
return null;
}
span.setAttributes({ const payload = (await response.json()) as ChatCompletionResponse;
"gen_ai.response.finish_reasons": payload.choices const result = provider.toResult(payload, endpoint.completionUrl);
?.map((choice) => choice.finish_reason ?? "unknown")
.filter((reason): reason is string => Boolean(reason)),
"gen_ai.usage.input_tokens": payload.usage?.prompt_tokens,
"gen_ai.usage.output_tokens": payload.usage?.completion_tokens,
});
if (!result) { span.setAttributes({
logger.warn( "gen_ai.response.finish_reasons": payload.choices
{ ?.map((choice) => choice.finish_reason ?? "unknown")
endpoint: endpoint.completionUrl, .filter((reason): reason is string => Boolean(reason)),
provider: provider.name, "gen_ai.usage.input_tokens": payload.usage?.prompt_tokens,
}, "gen_ai.usage.output_tokens": payload.usage?.completion_tokens,
"[LLM] Empty response from endpoint", });
);
return null;
}
return result; if (!result) {
}, logger.warn(
); {
endpoint: endpoint.completionUrl,
provider: provider.name,
model: request.model,
},
"[LLM] Empty response from endpoint",
);
return null;
}
if (!llmResult) { return result;
await this.circuit.recordFailure(endpoint.completionUrl); },
continue; );
if (llmResult) {
await this.circuit.recordSuccess(endpoint.completionUrl);
endpointSucceeded = true;
return llmResult;
}
} catch (error) {
logger.warn(
{
endpoint: endpoint.completionUrl,
provider: provider.name,
model,
error: error instanceof Error ? error.message : String(error),
},
"[LLM] Request error",
);
} }
}
await this.circuit.recordSuccess(endpoint.completionUrl); if (!endpointSucceeded) {
return llmResult;
} catch (error) {
await this.circuit.recordFailure(endpoint.completionUrl); await this.circuit.recordFailure(endpoint.completionUrl);
logger.warn(
{
endpoint: endpoint.completionUrl,
provider: provider.name,
error: error instanceof Error ? error.message : String(error),
},
"[LLM] Request error",
);
continue;
} }
} }
+33 -42
View File
@@ -2,24 +2,24 @@ import { afterEach, describe, expect, it, vi } from "vitest";
import type { LlmEndpointConfig } from "./types.js"; import type { LlmEndpointConfig } from "./types.js";
import { import {
selectMaxTokensForTier, selectMaxTokensForTier,
selectModelForProvider, selectModelsForProvider,
selectProviderOrder, selectProviderOrder,
} from "./routing.js"; } from "./routing.js";
describe("llm routing", () => { describe("llm routing", () => {
afterEach(() => { afterEach(() => {
delete process.env["OPENROUTER_ENABLED"]; delete process.env["OPENROUTER_MODEL"];
delete process.env["OPENROUTER_TIER1_MODEL"];
delete process.env["OPENROUTER_TIER2_MODEL"];
delete process.env["TIER0_MODEL"]; delete process.env["TIER0_MODEL"];
delete process.env["TIER1_PLANNER_MODEL"]; delete process.env["TIER1_PLANNER_MODEL"];
delete process.env["TIER1_RESPONDER_MODEL"]; delete process.env["TIER1_RESPONDER_MODEL"];
delete process.env["TIER2_CRITIC_MODEL"]; delete process.env["TIER2_CRITIC_MODEL"];
delete process.env["TIER0_MAX_TOKENS"];
delete process.env["TIER1_MAX_TOKENS"];
delete process.env["TIER2_MAX_TOKENS"];
vi.restoreAllMocks(); vi.restoreAllMocks();
}); });
it("prefers cliproxy then llama for tier 0 even when openrouter is enabled", () => { it("orders providers as cliproxy → openrouter → llama across all tiers", () => {
process.env["OPENROUTER_ENABLED"] = "true";
const endpoints: LlmEndpointConfig[] = [ const endpoints: LlmEndpointConfig[] = [
{ {
completionUrl: "http://llama.test/v1/chat/completions", completionUrl: "http://llama.test/v1/chat/completions",
@@ -40,53 +40,44 @@ describe("llm routing", () => {
expect( expect(
selectProviderOrder(endpoints, { tier: 0 }).map((endpoint) => endpoint.provider), selectProviderOrder(endpoints, { tier: 0 }).map((endpoint) => endpoint.provider),
).toEqual(["cliproxy", "llama"]); ).toEqual(["cliproxy", "openrouter", "llama"]);
});
it("includes openrouter between cliproxy and llama for tier 1+", () => {
process.env["OPENROUTER_ENABLED"] = "true";
const endpoints: LlmEndpointConfig[] = [
{
completionUrl: "http://llama.test/v1/chat/completions",
healthUrl: "http://llama.test/health",
provider: "llama",
},
{
completionUrl: "http://openrouter.test/v1/chat/completions",
healthUrl: "http://openrouter.test",
provider: "openrouter",
},
{
completionUrl: "http://cliproxy.test/v1/chat/completions",
healthUrl: "http://cliproxy.test",
provider: "cliproxy",
},
];
expect( expect(
selectProviderOrder(endpoints, { tier: 1 }).map((endpoint) => endpoint.provider), selectProviderOrder(endpoints, { tier: 1 }).map((endpoint) => endpoint.provider),
).toEqual(["cliproxy", "openrouter", "llama"]); ).toEqual(["cliproxy", "openrouter", "llama"]);
expect(
selectProviderOrder(endpoints, { tier: 2 }).map((endpoint) => endpoint.provider),
).toEqual(["cliproxy", "openrouter", "llama"]);
}); });
it("selects role-aware models per provider", () => { it("returns role-aware model for cliproxy and llama fallback as single-item list", () => {
process.env["TIER1_PLANNER_MODEL"] = "cliproxy-planner"; process.env["TIER1_PLANNER_MODEL"] = "cliproxy-planner";
process.env["TIER2_CRITIC_MODEL"] = "cliproxy-critic"; process.env["TIER2_CRITIC_MODEL"] = "cliproxy-critic";
process.env["OPENROUTER_TIER1_MODEL"] = "openrouter-tier1";
process.env["OPENROUTER_TIER2_MODEL"] = "openrouter-tier2";
expect( expect(
selectModelForProvider("cliproxy", { role: "planner", tier: 1 }, "local-qwen"), selectModelsForProvider("cliproxy", { role: "planner", tier: 1 }, "local-qwen"),
).toBe("cliproxy-planner"); ).toEqual(["cliproxy-planner"]);
expect( expect(
selectModelForProvider("cliproxy", { role: "critic", tier: 2 }, "local-qwen"), selectModelsForProvider("cliproxy", { role: "critic", tier: 2 }, "local-qwen"),
).toBe("cliproxy-critic"); ).toEqual(["cliproxy-critic"]);
expect(selectModelForProvider("openrouter", { tier: 1 }, "local-qwen")).toBe( expect(selectModelsForProvider("llama", { tier: 2 }, "local-qwen")).toEqual([
"openrouter-tier1", "local-qwen",
); ]);
});
it("splits OPENROUTER_MODEL by comma and preserves priority order", () => {
process.env["OPENROUTER_MODEL"] =
"google/gemma-4-26b-a4b-it:free, google/gemma-4-31b-it:free";
expect(selectModelsForProvider("openrouter", { tier: 1 }, "local-qwen")).toEqual([
"google/gemma-4-26b-a4b-it:free",
"google/gemma-4-31b-it:free",
]);
expect( expect(
selectModelForProvider("openrouter", { role: "critic", tier: 2 }, "local-qwen"), selectModelsForProvider("openrouter", { role: "critic", tier: 2 }, "local-qwen"),
).toBe("openrouter-tier2"); ).toEqual([
expect(selectModelForProvider("llama", { tier: 2 }, "local-qwen")).toBe("local-qwen"); "google/gemma-4-26b-a4b-it:free",
"google/gemma-4-31b-it:free",
]);
}); });
it("chooses tier defaults for max tokens when explicit maxTokens is absent", () => { it("chooses tier defaults for max tokens when explicit maxTokens is absent", () => {
+14 -24
View File
@@ -1,7 +1,5 @@
import { import {
getOpenRouterEnabled, getOpenRouterModels,
getOpenRouterTier1Model,
getOpenRouterTier2Model,
getTier0MaxTokens, getTier0MaxTokens,
getTier0Model, getTier0Model,
getTier1MaxTokens, getTier1MaxTokens,
@@ -13,38 +11,38 @@ import {
} from "../config.js"; } from "../config.js";
import type { ChatCompletionOptions, LlmEndpointConfig, ProviderName } from "./types.js"; import type { ChatCompletionOptions, LlmEndpointConfig, ProviderName } from "./types.js";
export function selectModelForProvider( const PROVIDER_PRIORITY: readonly ProviderName[] = ["cliproxy", "openrouter", "llama"];
export function selectModelsForProvider(
provider: ProviderName, provider: ProviderName,
options: ChatCompletionOptions | undefined, options: ChatCompletionOptions | undefined,
llamaFallbackModel: string, llamaFallbackModel: string,
): string { ): string[] {
if (options?.modelOverride?.trim()) { if (options?.modelOverride?.trim()) {
return options.modelOverride.trim(); return [options.modelOverride.trim()];
} }
if (provider === "llama") { if (provider === "llama") {
return llamaFallbackModel; return [llamaFallbackModel];
} }
if (provider === "openrouter") { if (provider === "openrouter") {
return options?.role === "critic" return getOpenRouterModels();
? getOpenRouterTier2Model()
: getOpenRouterTier1Model();
} }
if (options?.role === "planner") { if (options?.role === "planner") {
return getTier1PlannerModel(); return [getTier1PlannerModel()];
} }
if (options?.role === "critic") { if (options?.role === "critic") {
return getTier2CriticModel(); return [getTier2CriticModel()];
} }
if (options?.tier === 1 || options?.tier === 2) { if (options?.tier === 1 || options?.tier === 2) {
return getTier1ResponderModel(); return [getTier1ResponderModel()];
} }
return getTier0Model(); return [getTier0Model()];
} }
export function selectMaxTokensForTier( export function selectMaxTokensForTier(
@@ -71,20 +69,12 @@ export function selectMaxTokensForTier(
export function selectProviderOrder( export function selectProviderOrder(
endpoints: readonly LlmEndpointConfig[], endpoints: readonly LlmEndpointConfig[],
options: ChatCompletionOptions | undefined, _options: ChatCompletionOptions | undefined,
): LlmEndpointConfig[] { ): LlmEndpointConfig[] {
const preferredProviders: ProviderName[] = ["cliproxy"];
if (getOpenRouterEnabled() && options?.tier !== 0) {
preferredProviders.push("openrouter");
}
preferredProviders.push("llama");
const weighted = endpoints.map((endpoint, index) => ({ const weighted = endpoints.map((endpoint, index) => ({
endpoint, endpoint,
index, index,
priority: preferredProviders.indexOf(endpoint.provider), priority: PROVIDER_PRIORITY.indexOf(endpoint.provider),
})); }));
return weighted return weighted
+10 -10
View File
@@ -1,5 +1,5 @@
import { loadEnvironmentFromNodeEnv } from "./common/env-loader.js"; import { loadEnvironmentFromNodeEnv } from "./common/env-loader.js";
import { getOpenRouterApiUrl, getOpenRouterEnabled, getServiceName } from "./config.js"; import { getOpenRouterApiUrl, getServiceName } from "./config.js";
import type { GarnetClient } from "./common/garnet.js"; import type { GarnetClient } from "./common/garnet.js";
import type { NatsClient } from "./common/nats.js"; import type { NatsClient } from "./common/nats.js";
@@ -136,7 +136,15 @@ async function bootstrap(): Promise<void> {
getRawSecret("LLAMA_SERVER_API_URL"), getRawSecret("LLAMA_SERVER_API_URL"),
process.env["LLAMA_SERVER_API_URL"], process.env["LLAMA_SERVER_API_URL"],
); );
const openRouterEndpoints = getOpenRouterEnabled() const cliproxyApiKey = firstNonEmpty(
getRawSecret("CLI_PROXY_API_KEY"),
process.env["CLI_PROXY_API_KEY"],
);
const openRouterApiKey = firstNonEmpty(
getRawSecret("OPENROUTER_API_KEY"),
process.env["OPENROUTER_API_KEY"],
);
const openRouterEndpoints = openRouterApiKey
? parseEndpointList( ? parseEndpointList(
getRawSecret("OPENROUTER_API_URL"), getRawSecret("OPENROUTER_API_URL"),
process.env["OPENROUTER_API_URL"], process.env["OPENROUTER_API_URL"],
@@ -148,14 +156,6 @@ async function bootstrap(): Promise<void> {
...toProviderEndpoints(openRouterEndpoints, "openrouter"), ...toProviderEndpoints(openRouterEndpoints, "openrouter"),
...toProviderEndpoints(generalLlmEndpoints, "llama"), ...toProviderEndpoints(generalLlmEndpoints, "llama"),
]; ];
const cliproxyApiKey = firstNonEmpty(
getRawSecret("CLI_PROXY_API_KEY"),
process.env["CLI_PROXY_API_KEY"],
);
const openRouterApiKey = firstNonEmpty(
getRawSecret("OPENROUTER_API_KEY"),
process.env["OPENROUTER_API_KEY"],
);
const llmApiKey = firstNonEmpty( const llmApiKey = firstNonEmpty(
getRawSecret("AGENT_LLM_API_KEY"), getRawSecret("AGENT_LLM_API_KEY"),
process.env["AGENT_LLM_API_KEY"], process.env["AGENT_LLM_API_KEY"],
+12 -27
View File
@@ -1,28 +1,18 @@
export const VALID_TIERS = [ export const VALID_TIERS = ['GM', 'I', 'B', 'S', 'G', 'P', 'E', 'D', 'M', 'C', 'U'] as const;
"GM",
"I",
"B",
"S",
"G",
"P",
"E",
"D",
"M",
"C",
"U",
] as const;
export const VALID_TIER_SET = new Set<string>(VALID_TIERS); export const VALID_TIER_SET = new Set<string>(VALID_TIERS);
export const VALID_GENDERS = ["남", "여"] as const; export const VALID_GENDERS = ['남', '여'] as const;
export const VALID_GENDER_SET = new Set<string>(VALID_GENDERS); export const VALID_GENDER_SET = new Set<string>(VALID_GENDERS);
export const MIN_AGE = 27; export const MIN_AGE = 27;
export const MAX_AGE: number | null = null; export const MAX_AGE: number | null = null;
export const NICKNAME_FORMAT_EXAMPLE = "홍길동/95/남/G" as const; export const KAKAOTALK_NICKNAME_FORMAT_EXAMPLE = '면정학/89/남/D' as const;
export const TIER_CODES_TEXT = VALID_TIERS.join(", "); export const DISCORD_NICKNAME_FORMAT_EXAMPLE = '할리#프렌치불독/88/D' as const;
export const TIER_CODES_TEXT = VALID_TIERS.join(', ');
export const NICKNAME_FORMAT_TEXT = export const NICKNAME_FORMAT_TEXT = `카카오톡 닉네임은 이름/출생 연도 두 자리/성별/티어 형식이에요. 예를 들면 ${KAKAOTALK_NICKNAME_FORMAT_EXAMPLE}처럼 쓰시면 돼요.`;
`닉네임은 이름/출생 연도 두 자리/성별/티어 형식이에요. 예를 들면 ${NICKNAME_FORMAT_EXAMPLE}처럼 쓰시면 돼요.`;
export const DISCORD_NICKNAME_FORMAT_TEXT = `디스코드 서버 닉네임은 이름#태그/출생 연도 두 자리/티어 형식이에요. 카카오톡 형식과 달리 성별은 빼고 태그(#)가 들어가요. 예를 들면 ${DISCORD_NICKNAME_FORMAT_EXAMPLE}처럼 쓰시면 돼요.`;
export const HEART_RULE_TEXT = export const HEART_RULE_TEXT =
'채팅방 오른쪽 상단 메뉴 버튼에서 "커버 보기"로 들어가 하트를 빨간색으로 바꾼 뒤, 편집 없이 원본 스크린샷을 올려주시면 돼요.'; '채팅방 오른쪽 상단 메뉴 버튼에서 "커버 보기"로 들어가 하트를 빨간색으로 바꾼 뒤, 편집 없이 원본 스크린샷을 올려주시면 돼요.';
@@ -31,15 +21,10 @@ export const HEART_LOCATION_TEXT =
'채팅방 오른쪽 상단 메뉴 버튼을 누르면 "커버 보기"가 보여요. 거기서 프로필과 하트를 확인하실 수 있어요.'; '채팅방 오른쪽 상단 메뉴 버튼을 누르면 "커버 보기"가 보여요. 거기서 프로필과 하트를 확인하실 수 있어요.';
export const DISCORD_GUIDE_TEXT = export const DISCORD_GUIDE_TEXT =
"카카오톡 닉네임 변경과 방 하트 인증을 마치신 뒤, 디스코드 본인인증방과 구인방에 입장하고 서버 프로필 닉네임과 프로필 메시지를 설정하시면 권한이 자동으로 부여돼요."; '카카오톡 닉네임 변경과 방 하트 인증을 마치신 뒤, 카카오톡 본인인증방과 구인방에 입장하고 디스코드 서버 프로필 닉네임과 프로필 메시지를 설정하시면 권한이 자동으로 부여돼요.';
export const DISCORD_INVITE_URL = export const DISCORD_INVITE_URL = process.env['DISCORD_INVITE_URL']?.trim() || '';
process.env["DISCORD_INVITE_URL"]?.trim() || "";
export const DEADLINE_NEAR_THRESHOLD_MIN = Number( export const DEADLINE_NEAR_THRESHOLD_MIN = Number(process.env['DEADLINE_NEAR_THRESHOLD_MIN'] ?? 30);
process.env["DEADLINE_NEAR_THRESHOLD_MIN"] ?? 30,
);
export const ESCALATION_BUDGET_PER_TURN = Number( export const ESCALATION_BUDGET_PER_TURN = Number(process.env['ESCALATION_BUDGET_PER_TURN'] ?? 2);
process.env["ESCALATION_BUDGET_PER_TURN"] ?? 2,
);
+46 -59
View File
@@ -1,4 +1,4 @@
import type { NicknameIssue, OnboardingSession } from "./types.js"; import type { NicknameIssue, OnboardingSession } from './types.js';
import { import {
formatRemainingSteps, formatRemainingSteps,
getRemainingSteps, getRemainingSteps,
@@ -6,33 +6,33 @@ import {
isDiscordGuidanceUnlocked, isDiscordGuidanceUnlocked,
isOnboardingCompleted, isOnboardingCompleted,
isStep1Completed, isStep1Completed,
} from "./state/progress.js"; } from './state/progress.js';
import { import {
HEART_LOCATION_TEXT, HEART_LOCATION_TEXT,
HEART_RULE_TEXT, HEART_RULE_TEXT,
MIN_AGE, MIN_AGE,
NICKNAME_FORMAT_EXAMPLE, KAKAOTALK_NICKNAME_FORMAT_EXAMPLE,
NICKNAME_FORMAT_TEXT, NICKNAME_FORMAT_TEXT,
TIER_CODES_TEXT, TIER_CODES_TEXT,
VALID_GENDER_SET, VALID_GENDER_SET,
VALID_TIER_SET, VALID_TIER_SET,
} from "./constants.js"; } from './constants.js';
function pickRandom(items: [string, ...string[]]): string { function pickRandom(items: [string, ...string[]]): string {
return items[Math.floor(Math.random() * items.length)] ?? items[0]; return items[Math.floor(Math.random() * items.length)] ?? items[0];
} }
export function analyzeNicknameIssues(nickname: string): NicknameIssue[] { export function analyzeNicknameIssues(nickname: string): NicknameIssue[] {
const parts = nickname.trim().split("/"); const parts = nickname.trim().split('/');
const issues: NicknameIssue[] = []; const issues: NicknameIssue[] = [];
if (parts.length === 3) { if (parts.length === 3) {
const [, age, third] = parts; const [, age, third] = parts;
if (age && !/^\d{2}$/u.test(age)) { if (age && !/^\d{2}$/u.test(age)) {
issues.push({ issues.push({
kind: "invalid-age", kind: 'invalid-age',
message: "나이를 두 자리 숫자로 입력해주세요 (예: 25)", message: '나이를 두 자리 숫자로 입력해주세요 (예: 25)',
suggestion: "95", suggestion: '95',
}); });
} }
if (third) { if (third) {
@@ -40,32 +40,32 @@ export function analyzeNicknameIssues(nickname: string): NicknameIssue[] {
const rest = third.slice(1); const rest = third.slice(1);
if (hasGender && rest.length > 0 && !VALID_TIER_SET.has(rest)) { if (hasGender && rest.length > 0 && !VALID_TIER_SET.has(rest)) {
issues.push({ issues.push({
kind: "unknown-tier", kind: 'unknown-tier',
message: `성별 뒤의 '${rest}'를 제거하고, 티어 코드를 '/'로 구분해서 추가해주세요 (예: ${third.charAt(0)}/D)`, message: `성별 뒤의 '${rest}'를 제거하고, 티어 코드를 '/'로 구분해서 추가해주세요 (예: ${third.charAt(0)}/D)`,
suggestion: `${third.charAt(0)}/D`, suggestion: `${third.charAt(0)}/D`,
}); });
} else if (hasGender && rest.length > 0) { } else if (hasGender && rest.length > 0) {
issues.push({ issues.push({
kind: "wrong-separator", kind: 'wrong-separator',
message: `성별과 티어 코드는 '/'로 구분해서 입력해주세요 (예: ${third.charAt(0)}/${rest})`, message: `성별과 티어 코드는 '/'로 구분해서 입력해주세요 (예: ${third.charAt(0)}/${rest})`,
suggestion: `${third.charAt(0)}/${rest}`, suggestion: `${third.charAt(0)}/${rest}`,
}); });
} else if (!hasGender) { } else if (!hasGender) {
issues.push({ issues.push({
kind: "missing-gender", kind: 'missing-gender',
message: "성별(남/여)과 티어 코드를 '/'로 구분해서 입력해주세요", message: "성별(남/여)과 티어 코드를 '/'로 구분해서 입력해주세요",
}); });
} else { } else {
issues.push({ issues.push({
kind: "missing-tier", kind: 'missing-tier',
message: `티어 코드를 '/'로 구분해서 추가해주세요 (예: ${third}/D)`, message: `티어 코드를 '/'로 구분해서 추가해주세요 (예: ${third}/D)`,
suggestion: `${third}/D`, suggestion: `${third}/D`,
}); });
} }
} else { } else {
issues.push({ issues.push({
kind: "other", kind: 'other',
message: "성별과 티어 코드가 누락되었어요", message: '성별과 티어 코드가 누락되었어요',
}); });
} }
return issues; return issues;
@@ -73,7 +73,7 @@ export function analyzeNicknameIssues(nickname: string): NicknameIssue[] {
if (parts.length !== 4) { if (parts.length !== 4) {
issues.push({ issues.push({
kind: "wrong-separator", kind: 'wrong-separator',
message: `'/'로 구분된 4개 항목(이름/나이/성별/티어)이 필요해요. 현재 ${parts.length}개입니다.`, message: `'/'로 구분된 4개 항목(이름/나이/성별/티어)이 필요해요. 현재 ${parts.length}개입니다.`,
}); });
return issues; return issues;
@@ -83,22 +83,22 @@ export function analyzeNicknameIssues(nickname: string): NicknameIssue[] {
if (!age || !/^\d{2}$/u.test(age)) { if (!age || !/^\d{2}$/u.test(age)) {
issues.push({ issues.push({
kind: "invalid-age", kind: 'invalid-age',
message: "나이를 두 자리 숫자로 입력해주세요 (예: 25)", message: '나이를 두 자리 숫자로 입력해주세요 (예: 25)',
suggestion: "95", suggestion: '95',
}); });
} }
if (!gender || !VALID_GENDER_SET.has(gender)) { if (!gender || !VALID_GENDER_SET.has(gender)) {
issues.push({ issues.push({
kind: "missing-gender", kind: 'missing-gender',
message: "성별을 '남' 또는 '여'로 입력해주세요", message: "성별을 '남' 또는 '여'로 입력해주세요",
}); });
} }
if (!tier || !VALID_TIER_SET.has(tier)) { if (!tier || !VALID_TIER_SET.has(tier)) {
issues.push({ issues.push({
kind: "unknown-tier", kind: 'unknown-tier',
message: `티어 코드(${TIER_CODES_TEXT} 중 하나)를 입력해주세요`, message: `티어 코드(${TIER_CODES_TEXT} 중 하나)를 입력해주세요`,
}); });
} }
@@ -111,33 +111,33 @@ export function getWelcomeMessage(nickname: string): string {
`${nickname}님 환영합니다! 새내기 등록 1단계는 카카오톡 닉네임 변경과 하트 인증이에요.\n\n` + `${nickname}님 환영합니다! 새내기 등록 1단계는 카카오톡 닉네임 변경과 하트 인증이에요.\n\n` +
`1. 닉네임 변경: 이름/나이/성별/티어 형식 (예: 홍길동/25/남/G)\n` + `1. 닉네임 변경: 이름/나이/성별/티어 형식 (예: 홍길동/25/남/G)\n` +
`2. 하트 인증: 채팅방 프로필 하트를 빨간색으로 만들고 원본 스크린샷 전송\n` + `2. 하트 인증: 채팅방 프로필 하트를 빨간색으로 만들고 원본 스크린샷 전송\n` +
`3. 1단계 완료 후 디스코드 단계가 이어질 수 있어요.\n\n` + `3. 1단계 완료 후 카카오톡 본인인증방/구인방 입장과 디스코드 프로필 설정이 이어질 수 있어요.\n\n` +
`궁금한 점 있으시면 편하게 물어봐 주세요!`, `궁금한 점 있으시면 편하게 물어봐 주세요!`,
`${nickname}님 반갑습니다! 톡 게시글의 공지를 참고하셔서 먼저 카카오톡 닉네임 변경과 하트 인증을 진행해 주세요.\n\n` + `${nickname}님 반갑습니다! 톡 게시글의 공지를 참고하셔서 먼저 카카오톡 닉네임 변경과 하트 인증을 진행해 주세요.\n\n` +
`닉네임: 이름/나이/성별/티어 형식으로 변경 (예: 홍길동/25/남/G)\n` + `닉네임: 이름/나이/성별/티어 형식으로 변경 (예: 홍길동/25/남/G)\n` +
`하트 인증: 프로필 하트 빨간색 상태 원본 스크린샷 전송\n` + `하트 인증: 프로필 하트 빨간색 상태 원본 스크린샷 전송\n` +
`이후에는 디스코드 단계가 이어질 수 있어요.\n\n` + `이후에는 카카오톡 추가 방 입장과 디스코드 프로필 설정이 이어질 수 있어요.\n\n` +
`어떤 것부터 시작하시겠어요?`, `어떤 것부터 시작하시겠어요?`,
`${nickname}님 롤림푸스에 오신 걸 환영해요! 등록 절차를 안내해 드릴게요.\n\n` + `${nickname}님 롤림푸스에 오신 걸 환영해요! 등록 절차를 안내해 드릴게요.\n\n` +
`닉네임을 이름/나이/성별/티어 형식(예: 홍길동/25/남/G)으로 바꿔주시고, ` + `닉네임을 이름/나이/성별/티어 형식(예: 홍길동/25/남/G)으로 바꿔주시고, ` +
`채팅방 프로필 하트를 빨간색으로 만든 원본 스크린샷을 보내주시면 됩니다. ` + `채팅방 프로필 하트를 빨간색으로 만든 원본 스크린샷을 보내주시면 됩니다. ` +
`카카오톡 1단계가 끝나면 디스코드 단계가 이어질 수 있어요.`, `카카오톡 1단계가 끝나면 카카오톡 추가 방 입장과 디스코드 프로필 설정이 이어질 수 있어요.`,
]); ]);
} }
export function getGreetingMessage(): string { export function getGreetingMessage(): string {
return pickRandom([ return pickRandom([
"환영합니다! 반갑습니다.", '환영합니다! 반갑습니다.',
"반갑습니다! 어서 오세요.", '반갑습니다! 어서 오세요.',
"환영해요! 반갑습니다.", '환영해요! 반갑습니다.',
]); ]);
} }
export function getAcknowledgementMessage(): string { export function getAcknowledgementMessage(): string {
return pickRandom([ return pickRandom([
"네, 편하게 진행해 보시면 돼요.", '네, 편하게 진행해 보시면 돼요.',
"좋아요! 천천히 진행해 주세요.", '좋아요! 천천히 진행해 주세요.',
"네, 그렇게 해주시면 돼요.", '네, 그렇게 해주시면 돼요.',
]); ]);
} }
@@ -159,20 +159,20 @@ export function getNicknameInvalidMessage(
`@${nickname}님 닉네임을 조금만 수정해 주세요!`, `@${nickname}님 닉네임을 조금만 수정해 주세요!`,
]); ]);
return `${prefix}\n${issues.map((issue) => issue.message).join("\n")}`; return `${prefix}\n${issues.map((issue) => issue.message).join('\n')}`;
} }
export function getNicknameFormatMessage(): string { export function getNicknameFormatMessage(): string {
return pickRandom([ return pickRandom([
NICKNAME_FORMAT_TEXT, NICKNAME_FORMAT_TEXT,
`닉네임은 이름/출생 연도 두 자리/성별/티어 형식으로 입력해 주시면 돼요! 예: ${NICKNAME_FORMAT_EXAMPLE}`, `닉네임은 이름/출생 연도 두 자리/성별/티어 형식으로 입력해 주시면 돼요! 예: ${KAKAOTALK_NICKNAME_FORMAT_EXAMPLE}`,
]); ]);
} }
export function getHeartGuideMessage(): string { export function getHeartGuideMessage(): string {
return pickRandom([ return pickRandom([
HEART_RULE_TEXT, HEART_RULE_TEXT,
"채팅방 프로필에서 하트를 눌러 빨간색으로 만든 다음, 그 화면이 보이게 원본 스크린샷을 보내주시면 인증돼요.", '채팅방 프로필에서 하트를 눌러 빨간색으로 만든 다음, 그 화면이 보이게 원본 스크린샷을 보내주시면 인증돼요.',
]); ]);
} }
@@ -199,24 +199,19 @@ export function getPhotoFailedMessage(nickname: string): string {
]); ]);
} }
export function getProgressMessage( export function getProgressMessage(nickname: string, session: OnboardingSession): string {
nickname: string, const nicknameIcon = session.nicknameVerified ? 'v' : 'x';
session: OnboardingSession, const photoIcon = session.photoVerified ? 'v' : 'x';
): string { const discordNicknameIcon = session.discordProfileNicknameVerified === true ? 'v' : 'x';
const nicknameIcon = session.nicknameVerified ? "v" : "x"; const discordMessageIcon = session.discordProfileMessageVerified === true ? 'v' : 'x';
const photoIcon = session.photoVerified ? "v" : "x";
const discordNicknameIcon =
session.discordProfileNicknameVerified === true ? "v" : "x";
const discordMessageIcon =
session.discordProfileMessageVerified === true ? "v" : "x";
const remaining = getRemainingSteps(session); const remaining = getRemainingSteps(session);
const remainingText = const remainingText =
remaining.length > 0 remaining.length > 0
? `\n\n이제 ${formatRemainingSteps(remaining)}만 남아 있어요.` ? `\n\n이제 ${formatRemainingSteps(remaining)}만 남아 있어요.`
: "\n\n이제 새내기 등록 절차는 모두 완료됐어요."; : '\n\n이제 새내기 등록 절차는 모두 완료됐어요.';
const extendedStatus = hasExtendedOnboardingTracking(session) const extendedStatus = hasExtendedOnboardingTracking(session)
? ` | 디스코드 닉네임 [${discordNicknameIcon}] | 디스코드 메시지 [${discordMessageIcon}]` ? ` | 디스코드 닉네임 [${discordNicknameIcon}] | 디스코드 메시지 [${discordMessageIcon}]`
: ""; : '';
return ( return (
`${nickname}님 현재 진행상황: 카카오톡 닉네임 [${nicknameIcon}] | 방 하트 인증 [${photoIcon}]${extendedStatus}` + `${nickname}님 현재 진행상황: 카카오톡 닉네임 [${nicknameIcon}] | 방 하트 인증 [${photoIcon}]${extendedStatus}` +
@@ -238,10 +233,7 @@ export function getCompletedMessage(nickname: string): string {
]); ]);
} }
export function getGenericHelpMessage( export function getGenericHelpMessage(nickname: string, session: OnboardingSession | null): string {
nickname: string,
session: OnboardingSession | null,
): string {
if (!session || !isStep1Completed(session)) { if (!session || !isStep1Completed(session)) {
return pickRandom([ return pickRandom([
`톡 게시글의 공지를 참고하셔서 먼저 카카오톡 닉네임 변경과 하트 인증을 진행해 주세요!`, `톡 게시글의 공지를 참고하셔서 먼저 카카오톡 닉네임 변경과 하트 인증을 진행해 주세요!`,
@@ -272,26 +264,21 @@ export function getGenericHelpMessage(
)}만 진행하시면 돼요!`; )}만 진행하시면 돼요!`;
} }
export function getRemainingStatusMessage( export function getRemainingStatusMessage(session: OnboardingSession | null): string {
session: OnboardingSession | null,
): string {
const remaining = getRemainingSteps(session); const remaining = getRemainingSteps(session);
if (remaining.length === 0) { if (remaining.length === 0) {
return "이제 새내기 등록 절차는 모두 완료됐어요."; return '이제 새내기 등록 절차는 모두 완료됐어요.';
} }
return `이제 ${formatRemainingSteps(remaining)}만 남아 있어요.`; return `이제 ${formatRemainingSteps(remaining)}만 남아 있어요.`;
} }
export function getDiscordMessage( export function getDiscordMessage(nickname: string, session: OnboardingSession | null): string {
nickname: string,
session: OnboardingSession | null,
): string {
if (!isDiscordGuidanceUnlocked(session)) { if (!isDiscordGuidanceUnlocked(session)) {
return pickRandom([ return pickRandom([
`${nickname}님 카카오톡 닉네임 변경과 하트 인증을 먼저 완료해 주셔야 디스코드 안내를 드릴 수 있어요!`, `${nickname}님 카카오톡 닉네임 변경과 하트 인증을 먼저 완료해 주셔야 디스코드 안내를 드릴 수 있어요!`,
`${nickname}님 디스코드 단계는 카카오톡 닉네임 변경과 하트 인증을 모두 완료하신 뒤에 안내드릴게요!`, `${nickname}님 디스코드 관련 안내는 카카오톡 닉네임 변경과 하트 인증을 모두 완료하신 뒤에 도와드릴게요!`,
]); ]);
} }
@@ -300,14 +287,14 @@ export function getDiscordMessage(
`${nickname}님 카카오톡 절차는 완료됐어요! 이제 ${formatRemainingSteps( `${nickname}님 카카오톡 절차는 완료됐어요! 이제 ${formatRemainingSteps(
getRemainingSteps(session), getRemainingSteps(session),
)}만 진행하시면 돼요.`, )}만 진행하시면 돼요.`,
`${nickname}님 이제 디스코드 단계만 남았어요. ${formatRemainingSteps( `${nickname}님 이제 추가 절차만 남았어요. ${formatRemainingSteps(
getRemainingSteps(session), getRemainingSteps(session),
)}을 확인해 주세요.`, )}을 확인해 주세요.`,
]); ]);
} }
return pickRandom([ return pickRandom([
`${nickname}님 디스코드 단계까지 모두 완료되셨어요! 권한이 자동으로 부여될 거예요.`, `${nickname}님 카카오톡 방 입장과 디스코드 설정까지 모두 완료되셨어요! 권한이 자동으로 부여될 거예요.`,
`${nickname}님 모든 새내기 등록 절차가 끝났어요! 디스코드 권한 반영만 잠시 기다려 주세요.`, `${nickname}님 모든 새내기 등록 절차가 끝났어요! 디스코드 권한 반영만 잠시 기다려 주세요.`,
]); ]);
} }
+66 -59
View File
@@ -1,117 +1,124 @@
import type { Intent } from "../state/onboarding-state.js"; import type { Intent } from '../state/onboarding-state.js';
import type { Example } from "../types.js"; import type { Example } from '../types.js';
export const EXAMPLES_BY_INTENT: Record<Intent["kind"], Example[]> = { export const EXAMPLES_BY_INTENT: Record<Intent['kind'], Example[]> = {
greeting: [ greeting: [
{ {
user: "안녕하세요!", user: '안녕하세요!',
assistant: "환영합니다! 반갑습니다.", assistant: '어서오세요!',
}, },
{ {
user: "반갑습니다", user: '반갑습니다',
assistant: "반갑습니다! 어서 오세요.", assistant: '안녕하세요~',
}, },
], ],
acknowledgement: [ acknowledgement: [
{ {
user: "넵 확인했어요", user: '넵 확인했어요',
assistant: "네, 편하게 진행해 보시면 돼요.", assistant: '네, 편하게 진행해 보시면 돼요.',
}, },
{ {
user: "감사합니다", user: '감사합니다',
assistant: "좋아요! 천천히 진행해 주세요.", assistant: '좋아요! 천천히 진행해 주세요.',
}, },
], ],
"status-question": [ 'status-question': [
{ {
user: "이제 뭐 남았지?", user: '이제 뭐 남았지?',
assistant: "이제 디스코드 프로필 닉네임 설정과 프로필 메시지 설정만 남아 있어요.",
},
{
user: "진행상황 알려줘",
assistant: "아직 닉네임 변경과 방 하트 인증 두 가지가 남아 있어요.",
},
],
"help-how": [
{
user: "하트 인증은 어떻게 해요?",
assistant: assistant:
'채팅방 오른쪽 상단 메뉴 버튼에서 "커버 보기"로 들어가 하트를 빨간색으로 바꾼 뒤, 편집 없이 원본 스크린샷을 올려주시면 돼요.', '이제 디스코드 서버 프로필 닉네임 변경하시고 주민신청 채널에 메시지만 남겨주시면 돼요!',
}, },
{ {
user: "닉네임 형식 예시 알려줘", user: '이제 뭐 해야 할까요?',
assistant: assistant: '카톡 닉네임 변경해 주시고 방 하트 인증해 주시면 됩니다!',
"닉네임은 이름/출생 연도 두 자리/성별/티어 형식이에요. 예를 들면 홍길동/95/여/D처럼 쓰시면 돼요.",
}, },
], ],
"help-where": [ 'help-how': [
{ {
user: "하트 어디서 바꿔요?", user: '하트 인증은 어떻게 해요?',
assistant:
'채팅방 오른쪽 상단 메뉴 버튼에서 "커버 보기"로 들어가 하트를 클릭하시고, 편집 없이 원본 스크린샷을 올려주시면 돼요.',
},
{
user: '본인인증 방은 뭐에요?',
assistant:
'본인 계정을 사용하고 계신지 확인하는 절차가 있어요! 본인인증방은 담당 운영진이 확인 작업을 도와드리는 별도의 채팅방이에요.',
},
{
user: '닉네임 형식 예시 알려줘',
assistant:
'닉네임은 이름/출생 연도 두 자리/성별/티어 형식이에요. 예를 들면 면정학/89/남/D처럼 쓰시면 돼요.',
},
],
'help-where': [
{
user: '하트 어디서 바꿔요?',
assistant: assistant:
'채팅방 오른쪽 상단 메뉴 버튼을 누르면 "커버 보기"가 보여요. 거기서 프로필과 하트를 확인하실 수 있어요.', '채팅방 오른쪽 상단 메뉴 버튼을 누르면 "커버 보기"가 보여요. 거기서 프로필과 하트를 확인하실 수 있어요.',
}, },
], ],
"nickname-question": [ 'nickname-question': [
{ {
user: "닉네임이 왜 안 돼요?", user: '닉네임이 왜 안 돼요?',
assistant: assistant: '티어는 한 글자 코드로 넣어야 해요. 예를 들면 D처럼 바꿔주시면 돼요.',
"티어는 한 글자 코드로 넣어야 해요. 예를 들면 D처럼 바꿔주시면 돼요.",
}, },
{ {
user: "닉네임 형식이 뭐예요?", user: '닉네임 형식이 뭐예요?',
assistant: assistant: '닉네임은 이름/출생 연도 두 자리/성별/티어 형식으로 입력해 주시면 돼요.',
"닉네임은 이름/출생 연도 두 자리/성별/티어 형식으로 입력해 주시면 돼요.",
}, },
], ],
"photo-question": [ 'photo-question': [
{ {
user: "하트 인증이 뭐예요?", user: '하트 인증이 뭐예요?',
assistant: assistant:
"채팅방 프로필에서 하트를 빨간색으로 바꾼 뒤, 그 화면이 보이게 원본 스크린샷을 보내주시면 돼요.", '채팅방 프로필에서 하트를 빨간색으로 바꾼 뒤, 그 화면이 보이게 원본 스크린샷을 보내주시면 돼요.',
}, },
], ],
"discord-question": [ 'discord-question': [
{ {
user: "디스코드는 언제 들어가요?", user: '디스코드는 언제 들어가요?',
assistant: assistant:
"카카오톡 닉네임 변경과 하트 인증을 완료하셨다면, 이제 디스코드 방 입장과 프로필 설정을 진행하시면 돼요.", '카카오톡 닉네임 변경과 하트 인증을 완료하셨다면, 이제 카카오톡 본인인증방/구인방 입장과 디스코드 서버 프로필 설정을 진행하시면 돼요.',
}, },
], ],
"discord-verify-question": [ 'discord-verify-question': [
{ {
user: "디코 닉변 확인해줘", user: '디코 닉변 확인해줘',
assistant: assistant: '아직 디스코드 닉네임 변경은 확인되지 않았어요.',
"아직 디스코드 닉네임 변경은 확인되지 않았어요.",
}, },
{ {
user: "디스코드 프로필 닉네임 설정 완료했어요", user: '디스코드 프로필 닉네임 설정 완료했어요',
assistant: assistant:
"디스코드 닉네임을 확인해봤는데 아직 올바른 형식으로 확인되지는 않았어요.", '디스코드 닉네임을 확인해봤는데 아직 올바른 형식으로 확인되지는 않았어요. 디스코드 서버 닉네임은 이름#태그/출생 연도/티어 형식이에요. 예: 할리#프렌치불독/88/D',
},
{
user: '디스코드 닉네임 바꿨어요',
assistant:
'디스코드 닉네임이 아직 이름#태그/출생 연도/티어 형식으로 확인되지 않아요. 예: 할리#프렌치불독/88/D처럼 태그를 포함해서 설정해 주세요.',
}, },
], ],
"age-question": [ 'age-question': [
{ {
user: "나이 제한 있나요?", user: '나이 제한 있나요?',
assistant: "롤림푸스는 27세 이상만 가입이 가능해요.", assistant: '롤림푸스는 27세 이상만 가입이 가능해요.',
}, },
], ],
chitchat: [ chitchat: [
{ {
user: "오늘 날씨 좋네요", user: '오늘 날씨 좋네요',
assistant: "[NO_RESPONSE]", assistant: '[NO_RESPONSE]',
}, },
], ],
"off-topic-to-other": [ 'off-topic-to-other': [
{ {
user: "@프리리 이거 확인해줘", user: '@프리리 이거 확인해줘',
assistant: "[NO_RESPONSE]", assistant: '[NO_RESPONSE]',
}, },
], ],
unknown: [ unknown: [
{ {
user: "가입은 어떻게 하나요?", user: '가입은 어떻게 하나요?',
assistant: assistant: '톡 게시글의 공지를 참고하셔서 닉네임 변경과 하트 인증을 진행해 주세요!',
"톡 게시글의 공지를 참고하셔서 닉네임 변경과 하트 인증을 진행해 주세요!",
}, },
], ],
}; };
+99 -98
View File
@@ -1,46 +1,42 @@
import type { ConversationMessage } from "@agent/types"; import type { ConversationMessage } from '@agent/types';
import type { RoomMessage } from "@room/types"; import type { RoomMessage } from '@room/types';
import type { DerivedState, Intent } from "../state/onboarding-state.js"; import type { DerivedState, Intent } from '../state/onboarding-state.js';
import type { import type { Blackboard, Example, OnboardingSession, PromptContext } from '../types.js';
Blackboard,
Example,
OnboardingSession,
PromptContext,
} from "../types.js";
import { import {
HEART_RULE_TEXT, HEART_RULE_TEXT,
MIN_AGE, MIN_AGE,
NICKNAME_FORMAT_EXAMPLE, KAKAOTALK_NICKNAME_FORMAT_EXAMPLE,
DISCORD_NICKNAME_FORMAT_EXAMPLE,
TIER_CODES_TEXT, TIER_CODES_TEXT,
} from "../constants.js"; } from '../constants.js';
import { import {
formatRemainingSteps, formatRemainingSteps,
getRemainingSteps, getRemainingSteps,
hasExtendedOnboardingTracking, hasExtendedOnboardingTracking,
isStep1Completed, isStep1Completed,
} from "../state/progress.js"; } from '../state/progress.js';
import { EXAMPLES_BY_INTENT } from "./examples.js"; import { EXAMPLES_BY_INTENT } from './examples.js';
function formatKstTimestamp(value: string | undefined): string { function formatKstTimestamp(value: string | undefined): string {
if (!value) { if (!value) {
return "없음"; return '없음';
} }
const timestamp = Date.parse(value); const timestamp = Date.parse(value);
if (!Number.isFinite(timestamp)) { if (!Number.isFinite(timestamp)) {
return "없음"; return '없음';
} }
return new Intl.DateTimeFormat("ko-KR", { return new Intl.DateTimeFormat('ko-KR', {
dateStyle: "short", dateStyle: 'short',
timeStyle: "short", timeStyle: 'short',
timeZone: "Asia/Seoul", timeZone: 'Asia/Seoul',
}).format(new Date(timestamp)); }).format(new Date(timestamp));
} }
function formatNicknameStatus(session: OnboardingSession | null): string { function formatNicknameStatus(session: OnboardingSession | null): string {
if (!session) { if (!session) {
return "미완료"; return '미완료';
} }
return session.nicknameVerified return session.nicknameVerified
@@ -50,59 +46,55 @@ function formatNicknameStatus(session: OnboardingSession | null): string {
function formatPhotoStatus(session: OnboardingSession | null): string { function formatPhotoStatus(session: OnboardingSession | null): string {
if (!session) { if (!session) {
return "미완료"; return '미완료';
} }
return session.photoVerified ? "완료" : "미완료"; return session.photoVerified ? '완료' : '미완료';
} }
function formatOptionalVerificationStatus(value: boolean | undefined): string { function formatOptionalVerificationStatus(value: boolean | undefined): string {
if (value === undefined) { if (value === undefined) {
return "추적 안 함"; return '추적 안 함';
} }
return value ? "완료" : "미완료"; return value ? '완료' : '미완료';
} }
function formatHistory(history: ConversationMessage[]): string { function formatHistory(history: ConversationMessage[]): string {
if (history.length === 0) { if (history.length === 0) {
return "(최근 대화 없음)"; return '(최근 대화 없음)';
} }
return history.map((message) => `${message.role}: ${message.content}`).join("\n"); return history.map((message) => `${message.role}: ${message.content}`).join('\n');
} }
function formatRoomMessages(roomContext?: RoomMessage[]): string { function formatRoomMessages(roomContext?: RoomMessage[]): string {
if (!roomContext || roomContext.length === 0) { if (!roomContext || roomContext.length === 0) {
return "(방 분위기 정보 없음)"; return '(방 분위기 정보 없음)';
} }
return roomContext return roomContext
.slice(-5) .slice(-5)
.map((message) => `${message.nickname}: ${message.message}`) .map((message) => `${message.nickname}: ${message.message}`)
.join("\n"); .join('\n');
} }
function formatBlackboard(blackboard: Blackboard): string { function formatBlackboard(blackboard: Blackboard): string {
const openQuestions = const openQuestions =
blackboard.openQuestions.length > 0 blackboard.openQuestions.length > 0 ? blackboard.openQuestions.join(', ') : '(없음)';
? blackboard.openQuestions.join(", ")
: "(없음)";
const flaggedIssues = const flaggedIssues =
blackboard.flaggedIssues.length > 0 blackboard.flaggedIssues.length > 0 ? blackboard.flaggedIssues.join(', ') : '(없음)';
? blackboard.flaggedIssues.join(", ")
: "(없음)";
const nicknameAttempts = const nicknameAttempts =
blackboard.recentNicknameAttempts.length > 0 blackboard.recentNicknameAttempts.length > 0
? blackboard.recentNicknameAttempts.join(", ") ? blackboard.recentNicknameAttempts.join(', ')
: "(없음)"; : '(없음)';
return [ return [
`- lastIntent: ${blackboard.lastIntent ?? "(없음)"}`, `- lastIntent: ${blackboard.lastIntent ?? '(없음)'}`,
`- openQuestions: ${openQuestions}`, `- openQuestions: ${openQuestions}`,
`- flaggedIssues: ${flaggedIssues}`, `- flaggedIssues: ${flaggedIssues}`,
`- recentNicknameAttempts: ${nicknameAttempts}`, `- recentNicknameAttempts: ${nicknameAttempts}`,
].join("\n"); ].join('\n');
} }
function formatExample(example: Example): string { function formatExample(example: Example): string {
@@ -113,66 +105,80 @@ export function personaLayer(): string {
return `너는 롤림푸스(lolympus) 카카오톡 오픈채팅에서 새내기 등록을 도와주는 친절한 선배야. return `너는 롤림푸스(lolympus) 카카오톡 오픈채팅에서 새내기 등록을 도와주는 친절한 선배야.
처음 온 멤버가 편안하게 등록을 마칠 수 있도록 자연스럽고 정확하게 안내해줘. 처음 온 멤버가 편안하게 등록을 마칠 수 있도록 자연스럽고 정확하게 안내해줘.
[커뮤니티 규칙] [롤림푸스 규칙]
- 가입 가능 연령은 ${MIN_AGE}세 이상이야. - 가입 가능 연령은 ${MIN_AGE}세 이상이야.
- 새내기 등록 1단계는 카카오톡 닉네임 변경과 방 하트 인증이야. - 새내기 등록 1단계는 카카오톡 닉네임 변경과 방 하트 인증이야.
- 1단계 완료 후에는 디스코드 본인인증방/구인방 입장과 서버 프로필 설정이 남아 있을 수 있어. - 1단계 완료 후에는 카카오톡 본인인증방/구인방 입장과 디스코드 서버 프로필 설정, 디스코드 주민신청 채널 메시지 남기기가 남아 있을 수 있어.
- 닉네임 형식은 이름/출생 연도 두 자리/성별/티어야. 예: ${NICKNAME_FORMAT_EXAMPLE} - 카카오톡 닉네임 형식은 닉네임/출생 연도 두 자리/성별/티어야. 예: ${KAKAOTALK_NICKNAME_FORMAT_EXAMPLE}
- 디스코드 서버 닉네임 형식은 닉네임#태그/출생 연도 두 자리/티어야. 카카오톡 형식과 달리 성별은 빼고 태그(#)가 들어가. 예: ${DISCORD_NICKNAME_FORMAT_EXAMPLE}
- 디스코드 관련 질문(디코 닉변, 서버 프로필 등)에는 절대 카카오톡 형식(성별 포함)을 예시로 들지 마. 반드시 디스코드 형식만 안내해.
- 성별은 남 또는 여, 티어 코드는 ${TIER_CODES_TEXT} 중 하나야. - 성별은 남 또는 여, 티어 코드는 ${TIER_CODES_TEXT} 중 하나야.
- 방 하트 인증은 ${HEART_RULE_TEXT} - 방 하트 인증은 ${HEART_RULE_TEXT}
- 세션에 디스코드 관련 미완료 항목이 있으면 전체 등록은 아직 완료가 아니야. - 세션에 디스코드 관련 미완료 항목이 있으면 전체 등록은 아직 완료가 아니야.
- 디스코드 안내는 카카오톡 1단계가 완료된 뒤에만 해줘.`; - 디스코드 안내는 카카오톡 1단계가 완료된 뒤에만 해줘.`;
} }
export function policyLayer( export function policyLayer(intent: Intent, options?: { toolPolicy?: string | undefined }): string {
intent: Intent,
options?: { toolPolicy?: string | undefined },
): string {
const lines = [ const lines = [
"[답변 원칙]", '[답변 원칙]',
"- 마지막 메시지에서 직접 물은 내용에만 정확히 답해.", '- 마지막 메시지에서 직접 물은 내용에만 정확히 답해.',
"- 사용자가 요청하지 않은 다음 단계, 방법, 위치, 예시는 먼저 붙이지 마.", '- 사용자가 요청하지 않은 다음 단계, 방법, 위치, 예시는 먼저 붙이지 마.',
"- 마크다운 문법, 링크, URL은 쓰지 마.", '- 마크다운 문법, 링크, URL은 쓰지 마.',
'- 온보딩과 무관한 잡담이거나 다른 사람에게 하는 말이면 "[NO_RESPONSE]"만 출력해.', '- 온보딩과 무관한 잡담이거나 다른 사람에게 하는 말이면 "[NO_RESPONSE]"만 출력해.',
]; ];
switch (intent.kind) { switch (intent.kind) {
case "greeting": case 'greeting':
lines.push("- 짧은 인사만 1문장으로 답해."); lines.push('- 짧은 인사만 1문장으로 답해.');
break; break;
case "acknowledgement": case 'acknowledgement':
lines.push("- 짧은 확인이나 마무리만 1문장으로 답해."); lines.push('- 짧은 확인이나 마무리만 1문장으로 답해.');
break; break;
case "status-question": case 'status-question':
lines.push("- 현재 남은 절차나 완료 상태만 1문장으로 짧게 답해."); lines.push('- 완료된 것은 빼고 남은 절차만 간단하게 답해.');
lines.push("- 방법 설명, 위치 설명, 예시는 넣지 마."); lines.push('- 방법 설명, 위치 설명, 예시는 넣지 마.');
break; break;
case "help-where": case 'help-where':
lines.push("- 위치나 경로만 답하고, 요청하지 않은 다음 단계는 붙이지 마."); lines.push('- 위치나 경로만 답하고, 요청하지 않은 다음 단계는 붙이지 마.');
break; break;
case "help-how": case 'help-how':
lines.push("- 사용자가 물은 한 가지 절차의 방법만 답해."); lines.push(
'- 어떤 절차가 남아있는지 묻는 질문에는 완료된 건 말하지 말고 남은 절차만 짧게 말해.',
);
lines.push('- 사용자가 물은 한 가지 절차나 방의 의미/방법만 답해.');
lines.push(
'- 본인인증방이나 구인방이 무엇인지 묻는 질문에는 간단히 답하고, 본인인증방/구인방에 들어가서 어떻게 해야 하는지 묻는 경우 공지사항/안내메시지를 참조하라고 답해..',
);
break; break;
case "nickname-question": case 'nickname-question':
lines.push("- 닉네임 형식 또는 오류 원인만 답하고 다른 절차는 언급하지 마."); lines.push('- 닉네임 형식 또는 오류 원인만 답하고 다른 절차는 언급하지 마.');
break; break;
case "photo-question": case 'photo-question':
lines.push("- 하트 인증에 대해서만 답하고 다른 절차는 언급하지 마."); lines.push('- 하트 인증에 대해서만 답하고 다른 절차는 언급하지 마.');
break; break;
case "discord-question": case 'discord-question':
lines.push("- 디스코드 질문에만 답해. 카카오톡 1단계 전이라면 먼저 닉네임 변경과 하트 인증이 필요하다고 알려줘."); lines.push(
'- 디스코드 질문에만 답해. 카카오톡 1단계 전이라면 먼저 닉네임 변경과 하트 인증이 필요하다고 알려줘.',
);
lines.push(
'- 주민신청 채널이나 서버 프로필처럼 디스코드 공간/설정을 묻는 질문에는 용도와 역할을 자연스럽게 설명해.',
);
break; break;
case "discord-verify-question": case 'discord-verify-question':
lines.push("- 디스코드 닉네임 확인 결과만 답해."); lines.push('- 확인되지 않았으면 확인되지 않았다고만 답하고, 추측해서 단정하지 마.');
lines.push("- 확인되지 않았으면 확인되지 않았다고만 답하고, 추측해서 단정하지 마."); lines.push(
lines.push("- 카카오톡 닉네임 형식이 틀리면 예시를 1개만 들고 형식에 맞게 변경해 달라고 안내해."); `- 디스코드 닉네임 형식은 카카오톡과 달라. 반드시 이름#태그/출생 연도 두 자리/티어 형식(성별 없음, 태그 포함)으로 안내하고, 카카오톡 형식(이름/연도/성별/티어)을 절대 제시하지 마. 예시는 ${DISCORD_NICKNAME_FORMAT_EXAMPLE} 하나만 사용해.`,
lines.push("- 사용자가 묻지 않은 디스코드 절차나 다음 단계는 먼저 붙이지 마."); );
lines.push(
'- 디스코드 닉네임이 규칙에 맞지 않으면 위 형식과 예시를 1개만 들고 형식에 맞게 변경해 달라고 안내해.',
);
lines.push('- 사용자가 묻지 않은 디스코드 절차나 다음 단계는 먼저 붙이지 마.');
break; break;
case "age-question": case 'age-question':
lines.push("- 나이 제한만 간단히 답해."); lines.push('- 나이 제한만 간단히 답해.');
break; break;
default: default:
lines.push("- 질문 범위를 넘어서 먼저 설명하지 마."); lines.push('- 질문 범위를 넘어서 먼저 설명하지 마.');
break; break;
} }
@@ -180,52 +186,47 @@ export function policyLayer(
lines.push(options.toolPolicy); lines.push(options.toolPolicy);
} }
return lines.join("\n"); return lines.join('\n');
} }
export function stateLayer( export function stateLayer(session: OnboardingSession | null, derived: DerivedState): string {
session: OnboardingSession | null,
derived: DerivedState,
): string {
const remaining = getRemainingSteps(session); const remaining = getRemainingSteps(session);
return [ return [
"[현재 유저 상태]", '[현재 유저 상태]',
`- phase: ${derived.phase.kind}`, `- phase: ${derived.phase.kind}`,
`- step1(카카오톡): ${session ? (isStep1Completed(session) ? "완료" : "미완료") : "미완료"}`, `- step1(카카오톡): ${session ? (isStep1Completed(session) ? '완료' : '미완료') : '미완료'}`,
`- 카카오톡 닉네임: ${formatNicknameStatus(session)}`, `- 카카오톡 닉네임: ${formatNicknameStatus(session)}`,
`- 방 하트 인증: ${formatPhotoStatus(session)}`, `- 방 하트 인증: ${formatPhotoStatus(session)}`,
`- 디스코드 본인인증방 입장: ${formatOptionalVerificationStatus(session?.identityRoomJoined)}`, `- 카카오톡 본인인증방 입장: ${formatOptionalVerificationStatus(session?.identityRoomJoined)}`,
`- 디스코드 구인방 입장: ${formatOptionalVerificationStatus(session?.recruitingRoomJoined)}`, `- 카카오톡 구인방 입장: ${formatOptionalVerificationStatus(session?.recruitingRoomJoined)}`,
`- 디스코드 프로필 닉네임: ${formatOptionalVerificationStatus(session?.discordProfileNicknameVerified)}`, `- 디스코드 프로필 닉네임: ${formatOptionalVerificationStatus(session?.discordProfileNicknameVerified)}`,
`- 디스코드 프로필 메시지: ${formatOptionalVerificationStatus(session?.discordProfileMessageVerified)}`, `- 디스코드 프로필 메시지: ${formatOptionalVerificationStatus(session?.discordProfileMessageVerified)}`,
`- extendedTracking: ${hasExtendedOnboardingTracking(session) ? "on" : "off"}`, `- extendedTracking: ${hasExtendedOnboardingTracking(session) ? 'on' : 'off'}`,
`- remaining: ${remaining.length > 0 ? formatRemainingSteps(remaining) : "없음"}`, `- remaining: ${remaining.length > 0 ? formatRemainingSteps(remaining) : '없음'}`,
`- deadline(KST): ${formatKstTimestamp(session?.deadlineAt)}`, `- deadline(KST): ${formatKstTimestamp(session?.deadlineAt)}`,
].join("\n"); ].join('\n');
} }
export function examplesLayer(intent: Intent, count = 3): string { export function examplesLayer(intent: Intent, count = 3): string {
const examples = EXAMPLES_BY_INTENT[intent.kind].slice(0, count); const examples = EXAMPLES_BY_INTENT[intent.kind].slice(0, count);
const rendered = examples.length > 0 const rendered = examples.length > 0 ? examples.map(formatExample).join('\n\n') : '(예시 없음)';
? examples.map(formatExample).join("\n\n")
: "(예시 없음)";
return `[응답 예시]\n${rendered}`; return `[응답 예시]\n${rendered}`;
} }
export function contextLayer(context: PromptContext): string { export function contextLayer(context: PromptContext): string {
return [ return [
"[최근 요약]", '[최근 요약]',
context.summary ?? "(요약 없음)", context.summary ?? '(요약 없음)',
"", '',
"[최근 대화]", '[최근 대화]',
formatHistory(context.conversationHistory), formatHistory(context.conversationHistory),
"", '',
"[방 분위기]", '[방 분위기]',
formatRoomMessages(context.roomContext), formatRoomMessages(context.roomContext),
"", '',
"[메모]", '[메모]',
formatBlackboard(context.blackboard), formatBlackboard(context.blackboard),
].join("\n"); ].join('\n');
} }
+171 -264
View File
@@ -1,19 +1,16 @@
import type { AgentRequest, AgentResponse, ConversationMessage } from "@agent/types"; import type { AgentRequest, AgentResponse, ConversationMessage } from '@agent/types';
import { getConversationSummaryKey } from "@conv/conversation-store"; import { getConversationSummaryKey } from '@conv/conversation-store';
import type { GarnetClient } from "@common/garnet"; import type { GarnetClient } from '@common/garnet';
import type { NatsClient } from "@common/nats"; import type { NatsClient } from '@common/nats';
import { getContext, getRequestLogger } from "@obs/context"; import { getContext, getRequestLogger } from '@obs/context';
import type { LlmClient } from "@llm/llm-client"; import type { LlmClient } from '@llm/llm-client';
import type { ChatMessage } from "@llm/types"; import type { ChatMessage } from '@llm/types';
import type { RoomContextService } from "@room/room-context-service"; import type { RoomContextService } from '@room/room-context-service';
import type { Skill } from "@skills/skill"; import type { Skill } from '@skills/skill';
import { import { type ShadowEvalPublisher, ShadowEvalBus } from '@eval/shadow-bus';
type ShadowEvalPublisher, import { createBuiltInToolRegistry } from '@tools/builtins/index';
ShadowEvalBus, import type { Tool, ToolContext } from '@tools/tool';
} from "@eval/shadow-bus"; import { PromptBuilder } from './prompts/builder.js';
import { createBuiltInToolRegistry } from "@tools/builtins/index";
import type { Tool, ToolContext } from "@tools/tool";
import { PromptBuilder } from "./prompts/builder.js";
import { import {
getAcknowledgementMessage, getAcknowledgementMessage,
getAgeRequirementMessage, getAgeRequirementMessage,
@@ -29,28 +26,24 @@ import {
getProgressMessage, getProgressMessage,
getRemainingStatusMessage, getRemainingStatusMessage,
getTimeoutWarningMessage, getTimeoutWarningMessage,
} from "./onboarding-templates.js"; } from './onboarding-templates.js';
import { getOnboardingSessionKeyPrefix, getLlmTemperature } from "../../config.js"; import { getOnboardingSessionKeyPrefix, getLlmTemperature } from '../../config.js';
import { OnboardingBlackboardStore } from "./state/blackboard.js"; import { OnboardingBlackboardStore } from './state/blackboard.js';
import { deriveState } from "./state/derive.js"; import { deriveState } from './state/derive.js';
import { OnboardingIntentClassifier } from "./state/classifier.js"; import { OnboardingIntentClassifier } from './state/classifier.js';
import type { DerivedState, Intent } from "./state/onboarding-state.js"; import type { DerivedState, Intent } from './state/onboarding-state.js';
import { OnboardingOrchestrator } from "./runtime/orchestrator.js"; import { OnboardingOrchestrator } from './runtime/orchestrator.js';
import { validateOnboardingResponse } from "./runtime/validator.js"; import { validateOnboardingResponse } from './runtime/validator.js';
import { normalizeOnboardingSession } from "./session.js"; import { normalizeOnboardingSession } from './session.js';
import type { import type { OnboardingSession, PromptContext, StoredOnboardingSession } from './types.js';
OnboardingSession,
PromptContext,
StoredOnboardingSession,
} from "./types.js";
type LlmTextResult = type LlmTextResult =
| { status: "success"; text: string } | { status: 'success'; text: string }
| { status: "no_response" } | { status: 'no_response' }
| { status: "failed" }; | { status: 'failed' };
export class OnboardingSkill implements Skill { export class OnboardingSkill implements Skill {
readonly name = "onboarding"; readonly name = 'onboarding';
private readonly classifier: OnboardingIntentClassifier; private readonly classifier: OnboardingIntentClassifier;
private readonly blackboardStore: OnboardingBlackboardStore; private readonly blackboardStore: OnboardingBlackboardStore;
private readonly orchestrator: OnboardingOrchestrator; private readonly orchestrator: OnboardingOrchestrator;
@@ -62,18 +55,17 @@ export class OnboardingSkill implements Skill {
private readonly llmClient: LlmClient, private readonly llmClient: LlmClient,
private readonly roomContextService?: RoomContextService, private readonly roomContextService?: RoomContextService,
shadowEvalPublisher?: ShadowEvalPublisher, shadowEvalPublisher?: ShadowEvalPublisher,
private readonly natsClient?: Pick<NatsClient, "request">, private readonly natsClient?: Pick<NatsClient, 'request'>,
) { ) {
this.classifier = new OnboardingIntentClassifier(llmClient); this.classifier = new OnboardingIntentClassifier(llmClient);
this.blackboardStore = new OnboardingBlackboardStore(garnetClient); this.blackboardStore = new OnboardingBlackboardStore(garnetClient);
this.orchestrator = new OnboardingOrchestrator(llmClient); this.orchestrator = new OnboardingOrchestrator(llmClient);
this.shadowEvalPublisher = this.shadowEvalPublisher = shadowEvalPublisher ?? new ShadowEvalBus(garnetClient);
shadowEvalPublisher ?? new ShadowEvalBus(garnetClient);
this.tools = createBuiltInToolRegistry().list(); this.tools = createBuiltInToolRegistry().list();
} }
canHandle(request: AgentRequest): boolean { canHandle(request: AgentRequest): boolean {
return request.skill === "onboarding"; return request.skill === 'onboarding';
} }
async handle( async handle(
@@ -81,19 +73,13 @@ export class OnboardingSkill implements Skill {
conversationHistory: ConversationMessage[], conversationHistory: ConversationMessage[],
): Promise<AgentResponse> { ): Promise<AgentResponse> {
const logger = getRequestLogger(); const logger = getRequestLogger();
const session = await this.loadSession( const session = await this.loadSession(request.chatroomId, request.userId);
request.chatroomId,
request.userId,
);
if (request.trigger === "user-message" && !request.userMessage?.trim()) { if (request.trigger === 'user-message' && !request.userMessage?.trim()) {
return this.makeEmptyResponse(request.requestId); return this.makeEmptyResponse(request.requestId);
} }
const classified = await this.classifier.classify( const classified = await this.classifier.classify(request.userMessage, request.trigger);
request.userMessage,
request.trigger,
);
const derived = deriveState(session, request.trigger, classified.intent); const derived = deriveState(session, request.trigger, classified.intent);
if (!derived.shouldRespond) { if (!derived.shouldRespond) {
@@ -102,48 +88,33 @@ export class OnboardingSkill implements Skill {
let response: AgentResponse; let response: AgentResponse;
if (derived.responseMode === "template") { if (derived.responseMode === 'template') {
response = this.makeTemplateFallbackResponse( response = this.makeTemplateFallbackResponse(request, session, derived.intent, derived);
request,
session,
derived.intent,
derived,
);
} else { } else {
const llmResult = await this.handleLlm( const llmResult = await this.handleLlm(request, session, conversationHistory, derived);
request,
session,
conversationHistory,
derived,
);
if (llmResult.status === "success") { if (llmResult.status === 'success') {
response = this.makeLlmResponse(request.requestId, llmResult.text); response = this.makeLlmResponse(request.requestId, llmResult.text);
} else if (llmResult.status === "no_response") { } else if (llmResult.status === 'no_response') {
response = this.makeEmptyResponse(request.requestId); response = this.makeEmptyResponse(request.requestId);
} else { } else {
response = this.makeTemplateFallbackResponse( response = this.makeTemplateFallbackResponse(request, session, derived.intent, derived);
request,
session,
derived.intent,
derived,
);
} }
} }
if (derived.intent.kind === "discord-verify-question") { if (derived.intent.kind === 'discord-verify-question') {
logger.debug( logger.debug(
{ {
responseSource: response.source, responseSource: response.source,
responseText: response.text, responseText: response.text,
}, },
"[OnboardingSkill] Final discord verification response", '[OnboardingSkill] Final discord verification response',
); );
} }
if (response.text.trim()) { if (response.text.trim()) {
await this.rememberTurn(request, derived).catch((error) => { await this.rememberTurn(request, derived).catch((error) => {
logger.warn({ err: error }, "[OnboardingSkill] Failed to update blackboard"); logger.warn({ err: error }, '[OnboardingSkill] Failed to update blackboard');
}); });
this.shadowEvalPublisher.publish({ this.shadowEvalPublisher.publish({
@@ -159,10 +130,7 @@ export class OnboardingSkill implements Skill {
return response; return response;
} }
private async loadSession( private async loadSession(chatroomId: string, userId: string): Promise<OnboardingSession | null> {
chatroomId: string,
userId: string,
): Promise<OnboardingSession | null> {
const prefix = getOnboardingSessionKeyPrefix(); const prefix = getOnboardingSessionKeyPrefix();
const key = `${prefix}:onboarding:${chatroomId}:${userId}`; const key = `${prefix}:onboarding:${chatroomId}:${userId}`;
const rawSession = await this.garnetClient.getJson<StoredOnboardingSession>(key); const rawSession = await this.garnetClient.getJson<StoredOnboardingSession>(key);
@@ -175,20 +143,15 @@ export class OnboardingSkill implements Skill {
conversationHistory: ConversationMessage[], conversationHistory: ConversationMessage[],
derived: DerivedState, derived: DerivedState,
): Promise<LlmTextResult> { ): Promise<LlmTextResult> {
const messages = await this.buildLlmMessages( const messages = await this.buildLlmMessages(request, session, conversationHistory, derived);
request,
session,
conversationHistory,
derived,
);
return this.generateLlmText(messages, derived, { return this.generateLlmText(messages, derived, {
allowShortResponse: derived.allowShortResponse, allowShortResponse: derived.allowShortResponse,
maxTokens: derived.suggestedMaxTokens, maxTokens: derived.suggestedMaxTokens,
retryOnLowQuality: retryOnLowQuality:
request.trigger === "user-message" && request.trigger === 'user-message' &&
!derived.allowShortResponse && !derived.allowShortResponse &&
derived.responseMode !== "llm-with-tools", derived.responseMode !== 'llm-with-tools',
toolContext: this.buildToolContext(request, session), toolContext: this.buildToolContext(request, session),
tools: this.selectToolsForDerived(derived), tools: this.selectToolsForDerived(derived),
}); });
@@ -202,13 +165,11 @@ export class OnboardingSkill implements Skill {
): Promise<ChatMessage[]> { ): Promise<ChatMessage[]> {
const logger = getRequestLogger(); const logger = getRequestLogger();
const roomContextPromise = const roomContextPromise =
request.trigger === "user-message" && this.roomContextService request.trigger === 'user-message' && this.roomContextService
? this.roomContextService ? this.roomContextService.getRecentMessages(request.chatroomId).catch((error) => {
.getRecentMessages(request.chatroomId) logger.warn({ err: error }, '[OnboardingSkill] Failed to fetch room context');
.catch((error) => { return undefined;
logger.warn({ err: error }, "[OnboardingSkill] Failed to fetch room context"); })
return undefined;
})
: Promise.resolve(undefined); : Promise.resolve(undefined);
const [blackboard, summary, roomContext] = await Promise.all([ const [blackboard, summary, roomContext] = await Promise.all([
this.blackboardStore.load(request.chatroomId, request.userId), this.blackboardStore.load(request.chatroomId, request.userId),
@@ -227,28 +188,25 @@ export class OnboardingSkill implements Skill {
return PromptBuilder.forDerived(derived, session, context).build(); return PromptBuilder.forDerived(derived, session, context).build();
} }
private buildPromptUserMessage( private buildPromptUserMessage(request: AgentRequest, derived: DerivedState): string {
request: AgentRequest,
derived: DerivedState,
): string {
switch (request.trigger) { switch (request.trigger) {
case "nickname-invalid": case 'nickname-invalid':
return `현재 닉네임은 "${request.nickname}"예요. 왜 안 되는지와 어디를 고치면 되는지만 알려줘.`; return `현재 닉네임은 "${request.nickname}"예요. 왜 안 되는지와 어디를 고치면 되는지만 알려줘.`;
case "photo-failed": case 'photo-failed':
return "하트 인증 사진이 실패했어요. 다시 시도할 수 있게 필요한 내용만 안내해줘."; return '하트 인증 사진이 실패했어요. 다시 시도할 수 있게 필요한 내용만 안내해줘.';
case "progress-update": case 'progress-update':
return "현재 새내기 등록 진행상황만 짧게 알려줘."; return '현재 새내기 등록 진행상황만 짧게 알려줘.';
case "timeout-warning": case 'timeout-warning':
return "등록 마감이 가까워졌어요. 남은 절차만 짧고 따뜻하게 안내해줘."; return '등록 마감이 가까워졌어요. 남은 절차만 짧고 따뜻하게 안내해줘.';
case "completed": case 'completed':
return "새내기 등록을 모두 마친 유저에게 짧고 따뜻하게 축하 인사를 해줘."; return '새내기 등록을 모두 마친 유저에게 짧고 따뜻하게 축하 인사를 해줘.';
case "user-message": case 'user-message':
if (derived.intent.kind === "status-question") { if (derived.intent.kind === 'status-question') {
return "현재 남은 절차나 완료 상태만 1문장으로 아주 짧게 알려줘."; return '완료된 것은 빼고 남은 절차만 짧게 말해줘.';
} }
return request.userMessage?.trim() || "지금 필요한 온보딩 안내만 도와줘."; return request.userMessage?.trim() || '지금 필요한 온보딩 안내만 도와줘.';
default: default:
return "지금 필요한 온보딩 안내만 짧게 도와줘."; return '지금 필요한 온보딩 안내만 짧게 도와줘.';
} }
} }
@@ -260,68 +218,46 @@ export class OnboardingSkill implements Skill {
return (await this.garnetClient.getString(key)) ?? undefined; return (await this.garnetClient.getString(key)) ?? undefined;
} }
private async rememberTurn( private async rememberTurn(request: AgentRequest, derived: DerivedState): Promise<void> {
request: AgentRequest,
derived: DerivedState,
): Promise<void> {
const now = new Date().toISOString(); const now = new Date().toISOString();
const userMessage = request.userMessage?.trim(); const userMessage = request.userMessage?.trim();
await this.blackboardStore.update( await this.blackboardStore.update(request.chatroomId, request.userId, (current) => {
request.chatroomId, const openQuestions =
request.userId, userMessage &&
(current) => { (derived.intent.kind === 'help-how' ||
const openQuestions = derived.intent.kind === 'help-where' ||
userMessage && derived.intent.kind === 'nickname-question' ||
( derived.intent.kind === 'photo-question' ||
derived.intent.kind === "help-how" || derived.intent.kind === 'discord-question' ||
derived.intent.kind === "help-where" || derived.intent.kind === 'discord-verify-question')
derived.intent.kind === "nickname-question" || ? [...current.openQuestions, userMessage].slice(-3)
derived.intent.kind === "photo-question" || : current.openQuestions;
derived.intent.kind === "discord-question" ||
derived.intent.kind === "discord-verify-question"
)
? [...current.openQuestions, userMessage].slice(-3)
: current.openQuestions;
const recentNicknameAttempts = const recentNicknameAttempts =
request.trigger === "nickname-invalid" || request.trigger === 'nickname-invalid' || derived.intent.kind === 'nickname-question'
derived.intent.kind === "nickname-question" ? Array.from(new Set([...current.recentNicknameAttempts, request.nickname])).slice(-5)
? Array.from( : current.recentNicknameAttempts;
new Set([
...current.recentNicknameAttempts,
request.nickname,
]),
).slice(-5)
: current.recentNicknameAttempts;
return { return {
...current, ...current,
flaggedIssues: flaggedIssues:
derived.phase.kind === "nickname-rejected" derived.phase.kind === 'nickname-rejected'
? derived.phase.issues.map((issue) => issue.message) ? derived.phase.issues.map((issue) => issue.message)
: derived.phase.kind === "completed" : derived.phase.kind === 'completed'
? [] ? []
: current.flaggedIssues, : current.flaggedIssues,
lastIntent: derived.intent.kind, lastIntent: derived.intent.kind,
lastIntentAt: now, lastIntentAt: now,
openQuestions: openQuestions: derived.phase.kind === 'completed' ? [] : openQuestions,
derived.phase.kind === "completed" ? [] : openQuestions, recentNicknameAttempts,
recentNicknameAttempts, toneMemory: {
toneMemory: { ...current.toneMemory,
...current.toneMemory, greetedAt: derived.intent.kind === 'greeting' ? now : current.toneMemory.greetedAt,
greetedAt: thankedAt: derived.intent.kind === 'acknowledgement' ? now : current.toneMemory.thankedAt,
derived.intent.kind === "greeting" },
? now };
: current.toneMemory.greetedAt, });
thankedAt:
derived.intent.kind === "acknowledgement"
? now
: current.toneMemory.thankedAt,
},
};
},
);
} }
private makeTemplateFallbackResponse( private makeTemplateFallbackResponse(
@@ -331,35 +267,32 @@ export class OnboardingSkill implements Skill {
derived: DerivedState, derived: DerivedState,
): AgentResponse { ): AgentResponse {
switch (request.trigger) { switch (request.trigger) {
case "new-member": case 'new-member':
return this.makeEmptyResponse(request.requestId); return this.makeEmptyResponse(request.requestId);
case "nickname-invalid": case 'nickname-invalid':
return this.makeTemplateResponse( return this.makeTemplateResponse(
request.requestId, request.requestId,
getNicknameInvalidMessage(request.nickname, session), getNicknameInvalidMessage(request.nickname, session),
); );
case "photo-failed": case 'photo-failed':
return this.makeTemplateResponse( return this.makeTemplateResponse(
request.requestId, request.requestId,
getPhotoFailedMessage(request.nickname), getPhotoFailedMessage(request.nickname),
); );
case "progress-update": case 'progress-update':
return this.makeTemplateResponse( return this.makeTemplateResponse(
request.requestId, request.requestId,
session session
? getProgressMessage(request.nickname, session) ? getProgressMessage(request.nickname, session)
: getGenericHelpMessage(request.nickname, session), : getGenericHelpMessage(request.nickname, session),
); );
case "timeout-warning": case 'timeout-warning':
return this.makeTemplateResponse( return this.makeTemplateResponse(
request.requestId, request.requestId,
getTimeoutWarningMessage(request.nickname), getTimeoutWarningMessage(request.nickname),
); );
case "completed": case 'completed':
return this.makeTemplateResponse( return this.makeTemplateResponse(request.requestId, getCompletedMessage(request.nickname));
request.requestId,
getCompletedMessage(request.nickname),
);
default: default:
return this.makeTemplateResponse( return this.makeTemplateResponse(
request.requestId, request.requestId,
@@ -375,58 +308,55 @@ export class OnboardingSkill implements Skill {
derived: DerivedState, derived: DerivedState,
): string { ): string {
switch (intent.kind) { switch (intent.kind) {
case "greeting": case 'greeting':
return getGreetingMessage(); return getGreetingMessage();
case "acknowledgement": case 'acknowledgement':
return getAcknowledgementMessage(); return getAcknowledgementMessage();
case "status-question": case 'status-question':
return getRemainingStatusMessage(session); return getRemainingStatusMessage(session);
case "nickname-question": case 'nickname-question':
return derived.phase.kind === "nickname-rejected" return derived.phase.kind === 'nickname-rejected'
? getNicknameInvalidMessage(nickname, session) ? getNicknameInvalidMessage(nickname, session)
: getNicknameFormatMessage(); : getNicknameFormatMessage();
case "photo-question": case 'photo-question':
return derived.phase.kind === "photo-rejected" return derived.phase.kind === 'photo-rejected'
? getPhotoFailedMessage(nickname) ? getPhotoFailedMessage(nickname)
: getHeartGuideMessage(); : getHeartGuideMessage();
case "help-where": case 'help-where':
if ( if (
derived.phase.kind === "photo-pending" || derived.phase.kind === 'photo-pending' ||
derived.phase.kind === "photo-rejected" || derived.phase.kind === 'photo-rejected' ||
(derived.phase.kind === "deadline-near" && (derived.phase.kind === 'deadline-near' && derived.phase.remaining.includes('photo'))
derived.phase.remaining.includes("photo"))
) { ) {
return getHeartLocationMessage(); return getHeartLocationMessage();
} }
return getGenericHelpMessage(nickname, session); return getGenericHelpMessage(nickname, session);
case "help-how": case 'help-how':
if ( if (
derived.phase.kind === "nickname-pending" || derived.phase.kind === 'nickname-pending' ||
derived.phase.kind === "nickname-rejected" || derived.phase.kind === 'nickname-rejected' ||
(derived.phase.kind === "deadline-near" && (derived.phase.kind === 'deadline-near' && derived.phase.remaining.includes('nickname'))
derived.phase.remaining.includes("nickname"))
) { ) {
return getNicknameFormatMessage(); return getNicknameFormatMessage();
} }
if ( if (
derived.phase.kind === "photo-pending" || derived.phase.kind === 'photo-pending' ||
derived.phase.kind === "photo-rejected" || derived.phase.kind === 'photo-rejected' ||
(derived.phase.kind === "deadline-near" && (derived.phase.kind === 'deadline-near' && derived.phase.remaining.includes('photo'))
derived.phase.remaining.includes("photo"))
) { ) {
return getHeartGuideMessage(); return getHeartGuideMessage();
} }
return getGenericHelpMessage(nickname, session); return getGenericHelpMessage(nickname, session);
case "discord-question": case 'discord-question':
return getDiscordMessage(nickname, session); return getDiscordMessage(nickname, session);
case "discord-verify-question": case 'discord-verify-question':
return getDiscordMessage(nickname, session); return getDiscordMessage(nickname, session);
case "age-question": case 'age-question':
return getAgeRequirementMessage(); return getAgeRequirementMessage();
case "chitchat": case 'chitchat':
case "off-topic-to-other": case 'off-topic-to-other':
return ""; return '';
case "unknown": case 'unknown':
return getGenericHelpMessage(nickname, session); return getGenericHelpMessage(nickname, session);
} }
} }
@@ -444,7 +374,7 @@ export class OnboardingSkill implements Skill {
}, },
): Promise<LlmTextResult> { ): Promise<LlmTextResult> {
if (!this.llmClient.hasEndpoints()) { if (!this.llmClient.hasEndpoints()) {
return { status: "failed" }; return { status: 'failed' };
} }
const attempts: Array<{ const attempts: Array<{
@@ -490,49 +420,38 @@ export class OnboardingSkill implements Skill {
} }
const toolContext = options?.toolContext ?? {}; const toolContext = options?.toolContext ?? {};
const llmText = await this.orchestrator.run( const llmText = await this.orchestrator.run(derived, messages, {
derived, maxTokens: requestOptions.maxTokens,
messages, temperature: requestOptions.temperature,
{ toolContext,
maxTokens: requestOptions.maxTokens, tools: options?.tools,
temperature: requestOptions.temperature, });
toolContext,
tools: options?.tools,
},
);
if (!llmText) { if (!llmText) {
continue; continue;
} }
const validation = validateOnboardingResponse( const validation = validateOnboardingResponse(llmText, derived, {
llmText, allowShortResponse: options?.allowShortResponse,
derived, });
{
allowShortResponse: options?.allowShortResponse,
},
);
if (validation.text.includes("[NO_RESPONSE]")) { if (validation.text.includes('[NO_RESPONSE]')) {
return { status: "no_response" }; return { status: 'no_response' };
} }
if (validation.status === "reject") { if (validation.status === 'reject') {
continue; continue;
} }
return { return {
status: "success", status: 'success',
text: validation.text, text: validation.text,
}; };
} }
return { status: "failed" }; return { status: 'failed' };
} }
private buildToolContext( private buildToolContext(request: AgentRequest, session: OnboardingSession | null): ToolContext {
request: AgentRequest,
session: OnboardingSession | null,
): ToolContext {
return { return {
chatroomId: request.chatroomId, chatroomId: request.chatroomId,
natsClient: this.natsClient, natsClient: this.natsClient,
@@ -543,69 +462,57 @@ export class OnboardingSkill implements Skill {
}; };
} }
private selectToolsForDerived( private selectToolsForDerived(derived: DerivedState): readonly Tool<unknown, unknown>[] {
derived: DerivedState, if (derived.intent.kind === 'discord-verify-question') {
): readonly Tool<unknown, unknown>[] { return this.tools.filter((tool) => tool.name === 'verify-discord-nickname');
if (derived.intent.kind === "discord-verify-question") { }
return this.tools.filter((tool) =>
tool.name === "verify-discord-nickname", if (derived.phase.kind === 'nickname-rejected') {
return this.tools.filter(
(tool) =>
tool.name === 'validate-nickname' ||
tool.name === 'lookup-community-rule' ||
tool.name === 'check-onboarding-progress',
); );
} }
if (derived.phase.kind === "nickname-rejected") { if (derived.intent.kind === 'status-question') {
return this.tools.filter((tool) => return this.tools.filter((tool) => tool.name === 'check-onboarding-progress');
tool.name === "validate-nickname" ||
tool.name === "lookup-community-rule" ||
tool.name === "check-onboarding-progress",
);
} }
if (derived.intent.kind === "status-question") { if (derived.intent.kind === 'discord-question') {
return this.tools.filter((tool) => return this.tools.filter(
tool.name === "check-onboarding-progress", (tool) => tool.name === 'lookup-community-rule' || tool.name === 'verify-discord-nickname',
);
}
if (derived.intent.kind === "discord-question") {
return this.tools.filter((tool) =>
tool.name === "lookup-community-rule" ||
tool.name === "verify-discord-nickname",
); );
} }
return this.tools; return this.tools;
} }
private makeTemplateResponse( private makeTemplateResponse(requestId: string, text: string): AgentResponse {
requestId: string,
text: string,
): AgentResponse {
return { return {
requestId, requestId,
text, text,
confidence: 0.8, confidence: 0.8,
source: "template", source: 'template',
}; };
} }
private makeLlmResponse( private makeLlmResponse(requestId: string, text: string): AgentResponse {
requestId: string,
text: string,
): AgentResponse {
return { return {
requestId, requestId,
text, text,
confidence: 0.9, confidence: 0.9,
source: "llm", source: 'llm',
}; };
} }
private makeEmptyResponse(requestId: string): AgentResponse { private makeEmptyResponse(requestId: string): AgentResponse {
return { return {
requestId, requestId,
text: "", text: '',
confidence: 0, confidence: 0,
source: "template", source: 'template',
}; };
} }
@@ -51,4 +51,13 @@ describe("OnboardingIntentClassifier", () => {
expect(result.intent.kind).toBe("discord-verify-question"); expect(result.intent.kind).toBe("discord-verify-question");
expect(result.source).toBe("regex"); expect(result.source).toBe("regex");
}); });
it("classifies identity room questions as help-how", async () => {
const result = await classifier.classify(
"본인인증 방은 뭐에요?",
"user-message",
);
expect(result.intent.kind).toBe("help-how");
expect(result.source).toBe("regex");
});
}); });
+22
View File
@@ -76,6 +76,28 @@ function classifyByRegex(userMessage: string): ClassifiedIntent {
return { intent: intent("help-how"), confidence: 0.9, source: "regex" }; return { intent: intent("help-how"), confidence: 0.9, source: "regex" };
} }
if (
/(본인인증\s*방|본인인증방|구인\s*방|구인방)/u.test(trimmed)
) {
return {
intent: intent("help-how"),
confidence: 0.94,
source: "regex",
};
}
if (
/(주민신청\s*채널|주민신청채널|서버\s*프로필)/u.test(
trimmed,
)
) {
return {
intent: intent("discord-question"),
confidence: 0.94,
source: "regex",
};
}
const mentionsDiscord = /(디스코드|디코|discord)/u.test(lower); const mentionsDiscord = /(디스코드|디코|discord)/u.test(lower);
const asksDiscordVerification = const asksDiscordVerification =
/(확인|조회|찾아|검색|검사|바뀌|변경|닉변|맞(?:아|나요)?|됐(?:나|나요)?|완료됐(?:나|나요)?)/u.test( /(확인|조회|찾아|검색|검사|바뀌|변경|닉변|맞(?:아|나요)?|됐(?:나|나요)?|완료됐(?:나|나요)?)/u.test(
@@ -94,4 +94,30 @@ describe("deriveState", () => {
]); ]);
} }
}); });
it("includes discord room and profile steps together when all remain", () => {
const derived = deriveState(
makeSession({
discordProfileMessageVerified: false,
discordProfileNicknameVerified: false,
identityRoomJoined: false,
nicknameVerified: true,
photoVerified: true,
recruitingRoomJoined: false,
step1CompletedAt: new Date().toISOString(),
}),
"user-message",
intent("status-question"),
);
expect(derived.phase.kind).toBe("step1-completed");
if (derived.phase.kind === "step1-completed") {
expect(derived.phase.remaining).toEqual([
"identity-room",
"recruiting-room",
"discord-profile-nickname",
"discord-profile-message",
]);
}
});
}); });
@@ -4,11 +4,11 @@ export const EXPECTED_KEYWORDS: Record<Intent["kind"], string[]> = {
acknowledgement: ["네", "좋아요", "천천히"], acknowledgement: ["네", "좋아요", "천천히"],
"age-question": ["27", "가입", "가능"], "age-question": ["27", "가입", "가능"],
chitchat: [], chitchat: [],
"discord-question": ["디스코드", "프로필", "권한", "설정"], "discord-question": ["디스코드", "주민신청", "프로필", "권한", "설정"],
"discord-verify-question": ["디스코드", "확인", "닉네임"], "discord-verify-question": ["디스코드", "확인", "닉네임"],
greeting: ["반갑", "환영", "어서 오세요"], greeting: ["반갑", "환영", "어서 오세요"],
"help-how": ["하트", "닉네임", "스크린샷", "형식", "커버 보기"], "help-how": ["하트", "닉네임", "스크린샷", "형식", "본인인증방", "구인방", "운영진"],
"help-where": ["오른쪽 상단", "커버 보기", "프로필"], "help-where": ["오른쪽 상단", "커버 보기", "프로필", "본인인증방", "구인방", "채팅방"],
"nickname-question": ["닉네임", "형식", "티어", "/"], "nickname-question": ["닉네임", "형식", "티어", "/"],
"off-topic-to-other": [], "off-topic-to-other": [],
"photo-question": ["하트", "스크린샷", "프로필", "커버 보기"], "photo-question": ["하트", "스크린샷", "프로필", "커버 보기"],
+2 -18
View File
@@ -4,8 +4,8 @@ import type { RemainingStep } from './onboarding-state.js';
const REMAINING_STEP_LABELS: Record<RemainingStep, string> = { const REMAINING_STEP_LABELS: Record<RemainingStep, string> = {
nickname: '카카오톡 닉네임 변경', nickname: '카카오톡 닉네임 변경',
photo: '방 하트 인증', photo: '방 하트 인증',
'identity-room': '디스코드 본인인증방 입장', 'identity-room': '카카오톡 본인인증방 입장',
'recruiting-room': '디스코드 구인방 입장', 'recruiting-room': '카카오톡 구인방 입장',
'discord-profile-nickname': '디스코드 프로필 닉네임 설정', 'discord-profile-nickname': '디스코드 프로필 닉네임 설정',
'discord-profile-message': '디스코드 주민신청 채널에 메시지 남기기', 'discord-profile-message': '디스코드 주민신청 채널에 메시지 남기기',
}; };
@@ -58,18 +58,6 @@ function shouldTrackDiscordProfile(session: OnboardingSession | null): boolean {
); );
} }
function hasJoinedAllTrackedDiscordRooms(session: OnboardingSession | null): boolean {
if (!session) {
return false;
}
if (!shouldTrackDiscordRooms(session)) {
return true;
}
return session.identityRoomJoined !== false && session.recruitingRoomJoined !== false;
}
export function getRemainingSteps(session: OnboardingSession | null): RemainingStep[] { export function getRemainingSteps(session: OnboardingSession | null): RemainingStep[] {
if (!session) { if (!session) {
return ['nickname', 'photo']; return ['nickname', 'photo'];
@@ -102,10 +90,6 @@ export function getRemainingSteps(session: OnboardingSession | null): RemainingS
} }
} }
if (!hasJoinedAllTrackedDiscordRooms(session)) {
return remaining;
}
if (shouldTrackDiscordProfile(session)) { if (shouldTrackDiscordProfile(session)) {
if (session.discordProfileNicknameVerified === false) { if (session.discordProfileNicknameVerified === false) {
remaining.push('discord-profile-nickname'); remaining.push('discord-profile-nickname');
@@ -50,7 +50,42 @@ describe("checkOnboardingProgressTool", () => {
]); ]);
expect(result.remainingStepLabels).toEqual([ expect(result.remainingStepLabels).toEqual([
"디스코드 프로필 닉네임 설정", "디스코드 프로필 닉네임 설정",
"디스코드 프로필 메시지 설정", "디스코드 주민신청 채널에 메시지 남기기",
]);
});
it("returns all remaining discord steps when rooms and profile setup are both incomplete", async () => {
const result = await checkOnboardingProgressTool.execute(
{
chatroomId: "room-1",
userId: "user-1",
},
{
chatroomId: "room-1",
session: makeSession({
discordProfileMessageVerified: false,
discordProfileNicknameVerified: false,
identityRoomJoined: false,
recruitingRoomJoined: false,
step1CompletedAt: "2026-04-21T16:57:44.767Z",
}),
userId: "user-1",
},
);
expect(result.step1Done).toBe(true);
expect(result.overallDone).toBe(false);
expect(result.remainingSteps).toEqual([
"identity-room",
"recruiting-room",
"discord-profile-nickname",
"discord-profile-message",
]);
expect(result.remainingStepLabels).toEqual([
"카카오톡 본인인증방 입장",
"카카오톡 구인방 입장",
"디스코드 프로필 닉네임 설정",
"디스코드 주민신청 채널에 메시지 남기기",
]); ]);
}); });
+81 -96
View File
@@ -1,48 +1,49 @@
import { z } from "zod"; import { z } from 'zod';
import { import {
getDiscordMemberLookupSubject, getDiscordMemberLookupSubject,
getDiscordVerifyTimeoutMs, getDiscordVerifyTimeoutMs,
getOnboardingSessionKeyPrefix, getOnboardingSessionKeyPrefix,
} from "../../config.js"; } from '../../config.js';
import type { import type {
DiscordMemberCandidate, DiscordMemberCandidate,
DiscordMemberLookupRequest, DiscordMemberLookupRequest,
DiscordMemberLookupResponse, DiscordMemberLookupResponse,
} from "@common/nats-subjects"; } from '@common/nats-subjects';
import { getContext, getRequestLogger } from "@obs/context"; import { getContext, getRequestLogger } from '@obs/context';
import { import {
NICKNAME_FORMAT_EXAMPLE, KAKAOTALK_NICKNAME_FORMAT_EXAMPLE,
DISCORD_NICKNAME_FORMAT_EXAMPLE,
NICKNAME_FORMAT_TEXT, NICKNAME_FORMAT_TEXT,
} from "@skills/onboarding/constants"; } from '@skills/onboarding/constants';
import { analyzeNicknameIssues } from "@skills/onboarding/onboarding-templates"; import { analyzeNicknameIssues } from '@skills/onboarding/onboarding-templates';
import { import {
getKakaotalkNickname, getKakaotalkNickname,
matchesDiscordNicknameRule, matchesDiscordNicknameRule,
parseKakaoNickname, parseKakaoNickname,
} from "@skills/onboarding/session"; } from '@skills/onboarding/session';
import type { Tool, ToolContext } from "../tool.js"; import type { Tool, ToolContext } from '../tool.js';
const argsSchema = z.object({}).passthrough(); const argsSchema = z.object({}).passthrough();
const resultSchema = z.object({ const resultSchema = z.object({
status: z.enum([ status: z.enum([
"invalid-nickname-format", 'invalid-nickname-format',
"lookup-unavailable", 'lookup-unavailable',
"matched-pending-rename", 'matched-pending-rename',
"matched-renamed", 'matched-renamed',
"not-confirmed", 'not-confirmed',
]), ]),
message: z.string(), message: z.string(),
reason: z reason: z
.enum([ .enum([
"joined-after-ambiguous", 'joined-after-ambiguous',
"joined-after-none", 'joined-after-none',
"lookup-error", 'lookup-error',
"missing-search-name", 'missing-search-name',
"missing-session", 'missing-session',
"nickname-search-ambiguous", 'nickname-search-ambiguous',
"nickname-search-none", 'nickname-search-none',
"request-budget-exhausted", 'request-budget-exhausted',
]) ])
.optional(), .optional(),
expectedNickname: z.string().optional(), expectedNickname: z.string().optional(),
@@ -53,18 +54,14 @@ const resultSchema = z.object({
guidance: z.string().optional(), guidance: z.string().optional(),
issueMessages: z.array(z.string()).optional(), issueMessages: z.array(z.string()).optional(),
joinedAfterMatchCount: z.number().int().nonnegative().optional(), joinedAfterMatchCount: z.number().int().nonnegative().optional(),
matchSource: z.enum(["joined-after", "nickname"]).optional(), matchSource: z.enum(['joined-after', 'nickname']).optional(),
matchedBy: z matchedBy: z.enum(['global-name', 'guild-nickname', 'joined-after', 'username']).optional(),
.enum(["global-name", "guild-nickname", "joined-after", "username"])
.optional(),
nicknameMatchCount: z.number().int().nonnegative().optional(), nicknameMatchCount: z.number().int().nonnegative().optional(),
}); });
function pickDisplayName(candidate: DiscordMemberCandidate): string { function pickDisplayName(candidate: DiscordMemberCandidate): string {
return ( return (
candidate.guildNickname?.trim() || candidate.guildNickname?.trim() || candidate.globalName?.trim() || candidate.username.trim()
candidate.globalName?.trim() ||
candidate.username.trim()
); );
} }
@@ -84,10 +81,7 @@ function resolveTimeoutMs(): number | null {
return Math.min(configured, remainingMs); return Math.min(configured, remainingMs);
} }
async function persistDiscordMemberId( async function persistDiscordMemberId(memberId: string, ctx: ToolContext): Promise<void> {
memberId: string,
ctx: ToolContext,
): Promise<void> {
if (!ctx.garnetClient || !ctx.session) { if (!ctx.garnetClient || !ctx.session) {
return; return;
} }
@@ -105,19 +99,19 @@ export const verifyDiscordNicknameTool: Tool<
z.infer<typeof argsSchema>, z.infer<typeof argsSchema>,
z.infer<typeof resultSchema> z.infer<typeof resultSchema>
> = { > = {
name: "verify-discord-nickname", name: 'verify-discord-nickname',
description: description:
"현재 유저의 카카오톡 인증 닉네임과 세션 입장 시각을 기준으로 디스코드 멤버를 찾아, 닉네임 변경이 확인됐는지 구조화해서 반환한다.", '현재 유저의 카카오톡 인증 닉네임과 세션 입장 시각을 기준으로 디스코드 멤버를 찾아, 닉네임 변경이 확인됐는지 구조화해서 반환한다.',
argsSchema, argsSchema,
resultSchema, resultSchema,
async execute(_args, ctx) { async execute(_args, ctx) {
const logger = getRequestLogger(); const logger = getRequestLogger();
if (!ctx.session) { if (!ctx.session) {
logger.debug("[VerifyDiscordNickname] Missing session in tool context"); logger.debug('[VerifyDiscordNickname] Missing session in tool context');
return { return {
status: "lookup-unavailable" as const, status: 'lookup-unavailable' as const,
message: "세션 정보를 찾을 수 없어서 디스코드 닉네임을 조회할 수 없어요.", message: '세션 정보를 찾을 수 없어서 디스코드 닉네임을 조회할 수 없어요.',
reason: "missing-session" as const, reason: 'missing-session' as const,
}; };
} }
@@ -129,7 +123,7 @@ export const verifyDiscordNicknameTool: Tool<
nicknameVerified: ctx.session.nicknameVerified, nicknameVerified: ctx.session.nicknameVerified,
photoVerified: ctx.session.photoVerified, photoVerified: ctx.session.photoVerified,
}, },
"[VerifyDiscordNickname] Starting verification", '[VerifyDiscordNickname] Starting verification',
); );
const issues = analyzeNicknameIssues(expectedNickname); const issues = analyzeNicknameIssues(expectedNickname);
if (issues.length > 0) { if (issues.length > 0) {
@@ -138,31 +132,31 @@ export const verifyDiscordNicknameTool: Tool<
expectedNickname, expectedNickname,
issueMessages: issues.map((issue) => issue.message), issueMessages: issues.map((issue) => issue.message),
}, },
"[VerifyDiscordNickname] Nickname format invalid", '[VerifyDiscordNickname] Nickname format invalid',
); );
return { return {
status: "invalid-nickname-format" as const, status: 'invalid-nickname-format' as const,
message: `카카오톡 닉네임 형식이 올바르지 않아요. ${NICKNAME_FORMAT_TEXT}`, message: `카카오톡 닉네임 형식이 올바르지 않아요. ${NICKNAME_FORMAT_TEXT}`,
expectedNickname, expectedNickname,
formatExample: NICKNAME_FORMAT_EXAMPLE, formatExample: KAKAOTALK_NICKNAME_FORMAT_EXAMPLE,
guidance: NICKNAME_FORMAT_TEXT, guidance: NICKNAME_FORMAT_TEXT,
issueMessages: issues.map((issue) => issue.message), issueMessages: issues.map((issue) => issue.message),
}; };
} }
const parsedKakaoNickname = parseKakaoNickname(expectedNickname); const parsedKakaoNickname = parseKakaoNickname(expectedNickname);
const searchName = parsedKakaoNickname?.baseName ?? ""; const searchName = parsedKakaoNickname?.baseName ?? '';
if (!searchName) { if (!searchName) {
logger.debug( logger.debug(
{ {
expectedNickname, expectedNickname,
}, },
"[VerifyDiscordNickname] Failed to derive search name", '[VerifyDiscordNickname] Failed to derive search name',
); );
return { return {
status: "lookup-unavailable" as const, status: 'lookup-unavailable' as const,
message: "닉네임에서 검색할 이름을 추출할 수 없어서 디스코드 조회가 불가능해요.", message: '닉네임에서 검색할 이름을 추출할 수 없어서 디스코드 조회가 불가능해요.',
reason: "missing-search-name" as const, reason: 'missing-search-name' as const,
expectedNickname, expectedNickname,
}; };
} }
@@ -173,12 +167,12 @@ export const verifyDiscordNicknameTool: Tool<
expectedNickname, expectedNickname,
searchName, searchName,
}, },
"[VerifyDiscordNickname] Missing NATS client in tool context", '[VerifyDiscordNickname] Missing NATS client in tool context',
); );
return { return {
status: "lookup-unavailable" as const, status: 'lookup-unavailable' as const,
message: "지금은 디스코드 서버 조회가 불가능해요. 잠시 후 다시 시도해주세요.", message: '지금은 디스코드 서버 조회가 불가능해요. 잠시 후 다시 시도해주세요.',
reason: "lookup-error" as const, reason: 'lookup-error' as const,
expectedNickname, expectedNickname,
searchName, searchName,
}; };
@@ -191,12 +185,12 @@ export const verifyDiscordNicknameTool: Tool<
expectedNickname, expectedNickname,
searchName, searchName,
}, },
"[VerifyDiscordNickname] No timeout budget left for lookup", '[VerifyDiscordNickname] No timeout budget left for lookup',
); );
return { return {
status: "lookup-unavailable" as const, status: 'lookup-unavailable' as const,
message: "응답 시간이 부족해서 디스코드 조회를 건너뛰었어요. 다시 물어봐 주세요.", message: '응답 시간이 부족해서 디스코드 조회를 건너뛰었어요. 다시 물어봐 주세요.',
reason: "request-budget-exhausted" as const, reason: 'request-budget-exhausted' as const,
expectedNickname, expectedNickname,
searchName, searchName,
}; };
@@ -217,7 +211,7 @@ export const verifyDiscordNicknameTool: Tool<
subject: getDiscordMemberLookupSubject(), subject: getDiscordMemberLookupSubject(),
timeoutMs, timeoutMs,
}, },
"[VerifyDiscordNickname] Sending lookup request", '[VerifyDiscordNickname] Sending lookup request',
); );
lookupResult = await ctx.natsClient.request< lookupResult = await ctx.natsClient.request<
DiscordMemberLookupRequest, DiscordMemberLookupRequest,
@@ -231,30 +225,30 @@ export const verifyDiscordNicknameTool: Tool<
expectedNickname, expectedNickname,
searchName, searchName,
}, },
"[VerifyDiscordNickname] Lookup request failed", '[VerifyDiscordNickname] Lookup request failed',
); );
return { return {
status: "lookup-unavailable" as const, status: 'lookup-unavailable' as const,
message: "디스코드 서버 조회 중 오류가 발생했어요. 잠시 후 다시 시도해주세요.", message: '디스코드 서버 조회 중 오류가 발생했어요. 잠시 후 다시 시도해주세요.',
reason: "lookup-error" as const, reason: 'lookup-error' as const,
expectedNickname, expectedNickname,
searchName, searchName,
}; };
} }
if (lookupResult.status === "error") { if (lookupResult.status === 'error') {
logger.debug( logger.debug(
{ {
expectedNickname, expectedNickname,
reason: lookupResult.reason, reason: lookupResult.reason,
searchName, searchName,
}, },
"[VerifyDiscordNickname] Lookup service returned error", '[VerifyDiscordNickname] Lookup service returned error',
); );
return { return {
status: "lookup-unavailable" as const, status: 'lookup-unavailable' as const,
message: "디스코드 서버에서 오류가 반환됐어요. 잠시 후 다시 시도해주세요.", message: '디스코드 서버에서 오류가 반환됐어요. 잠시 후 다시 시도해주세요.',
reason: "lookup-error" as const, reason: 'lookup-error' as const,
expectedNickname, expectedNickname,
searchName, searchName,
}; };
@@ -269,30 +263,27 @@ export const verifyDiscordNicknameTool: Tool<
nicknameMatches: nicknameMatches.length, nicknameMatches: nicknameMatches.length,
searchName, searchName,
}, },
"[VerifyDiscordNickname] Lookup response received", '[VerifyDiscordNickname] Lookup response received',
); );
let candidate: DiscordMemberCandidate | null = null; let candidate: DiscordMemberCandidate | null = null;
let matchSource: "joined-after" | "nickname" | undefined; let matchSource: 'joined-after' | 'nickname' | undefined;
let reason: let reason:
| "joined-after-ambiguous" | 'joined-after-ambiguous'
| "joined-after-none" | 'joined-after-none'
| "nickname-search-ambiguous" | 'nickname-search-ambiguous'
| "nickname-search-none" | 'nickname-search-none'
| undefined; | undefined;
if (nicknameMatches.length === 1) { if (nicknameMatches.length === 1) {
candidate = nicknameMatches[0] ?? null; candidate = nicknameMatches[0] ?? null;
matchSource = "nickname"; matchSource = 'nickname';
} else if (nicknameMatches.length > 1) { } else if (nicknameMatches.length > 1) {
reason = "nickname-search-ambiguous"; reason = 'nickname-search-ambiguous';
} else if (joinedAfterMatches.length === 1) { } else if (joinedAfterMatches.length === 1) {
candidate = joinedAfterMatches[0] ?? null; candidate = joinedAfterMatches[0] ?? null;
matchSource = "joined-after"; matchSource = 'joined-after';
} else { } else {
reason = reason = joinedAfterMatches.length === 0 ? 'joined-after-none' : 'joined-after-ambiguous';
joinedAfterMatches.length === 0
? "joined-after-none"
: "joined-after-ambiguous";
} }
if (!candidate) { if (!candidate) {
@@ -303,21 +294,17 @@ export const verifyDiscordNicknameTool: Tool<
nicknameMatchCount: nicknameMatches.length, nicknameMatchCount: nicknameMatches.length,
reason: reason:
reason ?? reason ??
(nicknameMatches.length === 0 (nicknameMatches.length === 0 ? 'nickname-search-none' : 'nickname-search-ambiguous'),
? "nickname-search-none"
: "nickname-search-ambiguous"),
searchName, searchName,
}, },
"[VerifyDiscordNickname] Verification not confirmed", '[VerifyDiscordNickname] Verification not confirmed',
); );
return { return {
status: "not-confirmed" as const, status: 'not-confirmed' as const,
message: `디스코드 서버에서 "${searchName}" 닉네임을 찾을 수 없었어요. 디스코드 서버에 가입했는지, 닉네임이 올바른지 확인해주세요.`, message: `디스코드 서버에서 "${searchName}" 닉네임을 찾을 수 없었어요. 디스코드 서버에 가입했는지, 닉네임이 올바른지 확인해주세요.`,
reason: reason:
reason ?? reason ??
(nicknameMatches.length === 0 (nicknameMatches.length === 0 ? 'nickname-search-none' : 'nickname-search-ambiguous'),
? "nickname-search-none"
: "nickname-search-ambiguous"),
expectedNickname, expectedNickname,
searchName, searchName,
joinedAfterMatchCount: joinedAfterMatches.length, joinedAfterMatchCount: joinedAfterMatches.length,
@@ -329,16 +316,14 @@ export const verifyDiscordNicknameTool: Tool<
const currentDisplayName = pickDisplayName(candidate); const currentDisplayName = pickDisplayName(candidate);
const currentGuildNickname = candidate.guildNickname?.trim(); const currentGuildNickname = candidate.guildNickname?.trim();
const isRenamed = matchesDiscordNicknameRule( const isRenamed = matchesDiscordNicknameRule(currentGuildNickname, expectedNickname);
currentGuildNickname, const status = isRenamed ? 'matched-renamed' : 'matched-pending-rename';
expectedNickname, const discordFormatGuide = `디스코드 서버 닉네임은 이름#태그/출생연도/티어 형식이에요. 카카오톡 형식과 달리 성별은 빼고 태그(#)가 들어가요. 예: ${DISCORD_NICKNAME_FORMAT_EXAMPLE}`;
);
const status = isRenamed ? "matched-renamed" : "matched-pending-rename";
const message = isRenamed const message = isRenamed
? "디스코드 서버 닉네임이 올바른 형식으로 설정되어 있어요. 확인 완료!" ? '디스코드 서버 닉네임이 올바른 형식으로 설정되어 있어요. 확인 완료!'
: currentGuildNickname : currentGuildNickname
? `디스코드에서 유저를 찾았지만 서버 닉네임이 아직 올바른 형식으로 확인되지는 않았어요. 현재 서버 닉네임은 "${currentGuildNickname}"으로 보여요. 이름#태그/출생연도/티어 형식인지 확인해주세요.` ? `디스코드에서 유저를 찾았지만 서버 닉네임이 아직 올바른 형식으로 확인되지는 않았어요. 현재 서버 닉네임은 "${currentGuildNickname}"으로 보여요. ${discordFormatGuide}`
: `디스코드에서 유저를 찾았지만 서버 닉네임이 아직 설정되지 않았거나 확인되지 않았어요. 현재 표시 이름은 "${currentDisplayName}"으로 보여요. 서버 닉네임이 이름#태그/출생연도/티어 형식인지 확인해주세요.`; : `디스코드에서 유저를 찾았지만 서버 닉네임이 아직 설정되지 않았거나 확인되지 않았어요. 현재 표시 이름은 "${currentDisplayName}"으로 보여요. ${discordFormatGuide}`;
logger.debug( logger.debug(
{ {
@@ -349,7 +334,7 @@ export const verifyDiscordNicknameTool: Tool<
matchedBy: candidate.matchedBy, matchedBy: candidate.matchedBy,
status, status,
}, },
"[VerifyDiscordNickname] Verification resolved", '[VerifyDiscordNickname] Verification resolved',
); );
return { return {
+7 -12
View File
@@ -1,8 +1,5 @@
import { loadEnvironmentFromNodeEnv } from "../common/env-loader.js"; import { loadEnvironmentFromNodeEnv } from "../common/env-loader.js";
import { import { getOpenRouterApiUrl } from "../config.js";
getOpenRouterApiUrl,
getOpenRouterEnabled,
} from "../config.js";
loadEnvironmentFromNodeEnv(); loadEnvironmentFromNodeEnv();
@@ -131,7 +128,11 @@ async function bootstrap(): Promise<void> {
getRawSecret("LLAMA_SERVER_API_URL"), getRawSecret("LLAMA_SERVER_API_URL"),
process.env["LLAMA_SERVER_API_URL"], process.env["LLAMA_SERVER_API_URL"],
); );
const openRouterEndpoints = getOpenRouterEnabled() const openRouterApiKey = firstNonEmpty(
getRawSecret("OPENROUTER_API_KEY"),
process.env["OPENROUTER_API_KEY"],
);
const openRouterEndpoints = openRouterApiKey
? parseEndpointList( ? parseEndpointList(
getRawSecret("OPENROUTER_API_URL"), getRawSecret("OPENROUTER_API_URL"),
process.env["OPENROUTER_API_URL"], process.env["OPENROUTER_API_URL"],
@@ -154,13 +155,7 @@ async function bootstrap(): Promise<void> {
), ),
], ],
["llama", llmApiKey], ["llama", llmApiKey],
[ ["openrouter", openRouterApiKey],
"openrouter",
firstNonEmpty(
getRawSecret("OPENROUTER_API_KEY"),
process.env["OPENROUTER_API_KEY"],
),
],
].filter((entry): entry is [string, string] => typeof entry[1] === "string"), ].filter((entry): entry is [string, string] => typeof entry[1] === "string"),
) as Partial<Record<"cliproxy" | "llama" | "openrouter", string>>; ) as Partial<Record<"cliproxy" | "llama" | "openrouter", string>>;