feat: plan deterministic generated conversations
This commit is contained in:
Rijad Zuzo
@@ -0,0 +1,418 @@
|
||||
class_name ConversationService
|
||||
extends RefCounted
|
||||
|
||||
signal conversation_invalidated(conversation_id: StringName, reason_code: StringName)
|
||||
|
||||
const DEFAULT_CATALOG_PATH := "res://simulation/dialogue/resources/jajce_conversation_intents.tres"
|
||||
const REASON_ACCEPTED := &"accepted"
|
||||
const REASON_CONVERSATION_NOT_FOUND := &"conversation_not_found"
|
||||
const REASON_CONVERSATION_ENDED := &"conversation_ended"
|
||||
const REASON_INVALID_CONTEXT := &"invalid_context"
|
||||
const REASON_INVALID_PARTICIPANTS := &"invalid_participants"
|
||||
const REASON_STALE_REVISION := &"stale_revision"
|
||||
const REASON_OPTION_NOT_FOUND := &"option_not_found"
|
||||
const REASON_OPTION_DISABLED := &"option_disabled"
|
||||
const REASON_INVALIDATED := &"invalidated"
|
||||
|
||||
const CONTEXT_KEYS := [
|
||||
"conversation_key",
|
||||
"initial_intent_id",
|
||||
"topic_ids",
|
||||
"option_intent_ids",
|
||||
"topics_by_intent",
|
||||
"blocked_intent_ids",
|
||||
"block_reason_by_intent",
|
||||
"reason_trace",
|
||||
]
|
||||
|
||||
var last_error := ""
|
||||
|
||||
var _catalog: ConversationIntentCatalog
|
||||
var _records_by_id: Dictionary = {}
|
||||
var _next_sequence := 1
|
||||
|
||||
|
||||
func _init(intent_catalog: ConversationIntentCatalog = null) -> void:
|
||||
_catalog = intent_catalog
|
||||
if _catalog == null:
|
||||
_catalog = load(DEFAULT_CATALOG_PATH) as ConversationIntentCatalog
|
||||
if _catalog == null:
|
||||
last_error = "Conversation intent catalog could not be loaded"
|
||||
elif not _catalog.rebuild().is_empty():
|
||||
last_error = "; ".join(_catalog.get_errors())
|
||||
|
||||
|
||||
func begin(
|
||||
speaker: WorldEntityRef, listener: WorldEntityRef, context: Dictionary = {}
|
||||
) -> StringName:
|
||||
last_error = ""
|
||||
if not _participants_are_valid(speaker, listener):
|
||||
last_error = "Conversation participants are invalid"
|
||||
return &""
|
||||
var normalized: Variant = _normalize_context(context)
|
||||
if normalized == null:
|
||||
last_error = "Conversation context is invalid"
|
||||
return &""
|
||||
var conversation_id := _make_conversation_id(speaker, listener, normalized)
|
||||
var initial_intent_id := StringName(normalized["initial_intent_id"])
|
||||
var revision := 1
|
||||
var turn := _plan_turn(
|
||||
conversation_id, revision, speaker, listener, initial_intent_id, normalized, &"began"
|
||||
)
|
||||
if turn == null:
|
||||
last_error = "Initial conversation turn could not be planned"
|
||||
return &""
|
||||
_records_by_id[conversation_id] = {
|
||||
"speaker": speaker.duplicate_ref(),
|
||||
"listener": listener.duplicate_ref(),
|
||||
"context": normalized,
|
||||
"revision": revision,
|
||||
"turn": turn,
|
||||
"ended": false,
|
||||
"invalid_reason": &"",
|
||||
}
|
||||
return conversation_id
|
||||
|
||||
|
||||
func get_turn(conversation_id: StringName) -> ConversationTurn:
|
||||
var record: Dictionary = _records_by_id.get(conversation_id, {})
|
||||
if record.is_empty() or bool(record["ended"]):
|
||||
return null
|
||||
var turn := record["turn"] as ConversationTurn
|
||||
return turn.copy() if turn != null else null
|
||||
|
||||
|
||||
func select_option(
|
||||
conversation_id: StringName, option_id: StringName, expected_revision: int
|
||||
) -> ConversationSelectionResult:
|
||||
var record: Dictionary = _records_by_id.get(conversation_id, {})
|
||||
if record.is_empty():
|
||||
return _rejected(
|
||||
REASON_CONVERSATION_NOT_FOUND,
|
||||
expected_revision,
|
||||
-1,
|
||||
option_id,
|
||||
null,
|
||||
[&"conversation_missing"]
|
||||
)
|
||||
var current_revision := int(record["revision"])
|
||||
var current_turn := record["turn"] as ConversationTurn
|
||||
if bool(record["ended"]):
|
||||
var reason := StringName(record["invalid_reason"])
|
||||
return _rejected(
|
||||
reason if not reason.is_empty() else REASON_CONVERSATION_ENDED,
|
||||
expected_revision,
|
||||
current_revision,
|
||||
option_id,
|
||||
null,
|
||||
[&"conversation_closed"]
|
||||
)
|
||||
if expected_revision != current_revision:
|
||||
return _rejected(
|
||||
REASON_STALE_REVISION,
|
||||
expected_revision,
|
||||
current_revision,
|
||||
option_id,
|
||||
current_turn,
|
||||
[&"revision_mismatch", &"revalidation_required"]
|
||||
)
|
||||
var option := current_turn.get_option(option_id)
|
||||
if option == null:
|
||||
return _rejected(
|
||||
REASON_OPTION_NOT_FOUND,
|
||||
expected_revision,
|
||||
current_revision,
|
||||
option_id,
|
||||
current_turn,
|
||||
[&"option_missing", &"revalidation_required"]
|
||||
)
|
||||
if not option.is_enabled():
|
||||
return _rejected(
|
||||
REASON_OPTION_DISABLED,
|
||||
expected_revision,
|
||||
current_revision,
|
||||
option_id,
|
||||
current_turn,
|
||||
option.get_reason_trace()
|
||||
)
|
||||
|
||||
var next_revision := current_revision + 1
|
||||
var next_turn := _plan_turn(
|
||||
conversation_id,
|
||||
next_revision,
|
||||
record["listener"] as WorldEntityRef,
|
||||
record["speaker"] as WorldEntityRef,
|
||||
option.get_intent_id(),
|
||||
record["context"],
|
||||
&"option_selected"
|
||||
)
|
||||
if next_turn == null:
|
||||
return _rejected(
|
||||
REASON_INVALID_CONTEXT,
|
||||
expected_revision,
|
||||
current_revision,
|
||||
option_id,
|
||||
current_turn,
|
||||
[&"next_turn_unplannable"]
|
||||
)
|
||||
record["revision"] = next_revision
|
||||
record["turn"] = next_turn
|
||||
record["speaker"] = next_turn.get_speaker()
|
||||
record["listener"] = next_turn.get_listener()
|
||||
_records_by_id[conversation_id] = record
|
||||
return ConversationSelectionResult.new(
|
||||
true,
|
||||
REASON_ACCEPTED,
|
||||
expected_revision,
|
||||
next_revision,
|
||||
option_id,
|
||||
next_turn,
|
||||
[&"revision_matched", &"option_enabled", &"turn_advanced"]
|
||||
)
|
||||
|
||||
|
||||
func end(conversation_id: StringName, expected_revision: int = -1) -> bool:
|
||||
var record: Dictionary = _records_by_id.get(conversation_id, {})
|
||||
if record.is_empty() or bool(record["ended"]):
|
||||
return false
|
||||
if expected_revision >= 0 and expected_revision != int(record["revision"]):
|
||||
return false
|
||||
record["ended"] = true
|
||||
record["invalid_reason"] = REASON_CONVERSATION_ENDED
|
||||
record["turn"] = null
|
||||
_records_by_id[conversation_id] = record
|
||||
return true
|
||||
|
||||
|
||||
func invalidate(conversation_id: StringName, reason_code: StringName = REASON_INVALIDATED) -> bool:
|
||||
if not ConversationSemantic.is_valid_id(reason_code):
|
||||
return false
|
||||
var record: Dictionary = _records_by_id.get(conversation_id, {})
|
||||
if record.is_empty() or bool(record["ended"]):
|
||||
return false
|
||||
record["ended"] = true
|
||||
record["invalid_reason"] = reason_code
|
||||
record["turn"] = null
|
||||
_records_by_id[conversation_id] = record
|
||||
conversation_invalidated.emit(conversation_id, reason_code)
|
||||
return true
|
||||
|
||||
|
||||
func invalidate_for_entity(
|
||||
entity: WorldEntityRef, reason_code: StringName = REASON_INVALIDATED
|
||||
) -> Array[StringName]:
|
||||
var invalidated_ids: Array[StringName] = []
|
||||
if entity == null or not entity.is_valid() or not ConversationSemantic.is_valid_id(reason_code):
|
||||
return invalidated_ids
|
||||
var conversation_ids: Array[StringName] = []
|
||||
for conversation_id in _records_by_id:
|
||||
conversation_ids.append(conversation_id)
|
||||
conversation_ids.sort_custom(
|
||||
func(left: StringName, right: StringName) -> bool: return String(left) < String(right)
|
||||
)
|
||||
for conversation_id in conversation_ids:
|
||||
var record: Dictionary = _records_by_id[conversation_id]
|
||||
if bool(record["ended"]):
|
||||
continue
|
||||
var speaker := record["speaker"] as WorldEntityRef
|
||||
var listener := record["listener"] as WorldEntityRef
|
||||
if speaker.equals(entity) or listener.equals(entity):
|
||||
if invalidate(conversation_id, reason_code):
|
||||
invalidated_ids.append(conversation_id)
|
||||
return invalidated_ids
|
||||
|
||||
|
||||
func has_active_conversation(conversation_id: StringName) -> bool:
|
||||
var record: Dictionary = _records_by_id.get(conversation_id, {})
|
||||
return not record.is_empty() and not bool(record["ended"])
|
||||
|
||||
|
||||
func _plan_turn(
|
||||
conversation_id: StringName,
|
||||
revision: int,
|
||||
speaker: WorldEntityRef,
|
||||
listener: WorldEntityRef,
|
||||
intent_id: StringName,
|
||||
context: Dictionary,
|
||||
reason_id: StringName
|
||||
) -> ConversationTurn:
|
||||
if not _catalog.has_intent(intent_id):
|
||||
return null
|
||||
var topics := _topics_for_intent(intent_id, context)
|
||||
var act := ConversationAct.new(
|
||||
&"act_%d" % revision,
|
||||
intent_id,
|
||||
speaker,
|
||||
listener,
|
||||
topics,
|
||||
[reason_id, &"intent_%s" % intent_id]
|
||||
)
|
||||
var option_intent_ids := _option_intents_for(intent_id, context)
|
||||
var options: Array[ConversationOption] = []
|
||||
for option_index in range(option_intent_ids.size()):
|
||||
var option_intent_id: StringName = option_intent_ids[option_index]
|
||||
var blocked: bool = option_intent_id in (context["blocked_intent_ids"] as Array)
|
||||
var reason_code := StringName(
|
||||
(context["block_reason_by_intent"] as Dictionary).get(option_intent_id, "blocked")
|
||||
)
|
||||
var trace: Array[StringName] = [&"candidate_from_%s" % intent_id]
|
||||
trace.append(&"blocked_by_context" if blocked else &"available_by_context")
|
||||
options.append(
|
||||
ConversationOption.new(
|
||||
&"option_%d_%d_%s" % [revision, option_index, option_intent_id],
|
||||
option_intent_id,
|
||||
listener,
|
||||
speaker,
|
||||
_topics_for_intent(option_intent_id, context),
|
||||
not blocked,
|
||||
reason_code if blocked else &"",
|
||||
trace
|
||||
)
|
||||
)
|
||||
var terminal := intent_id == ConversationIntentIds.GOODBYE
|
||||
if terminal:
|
||||
options.clear()
|
||||
var reason_trace: Array[StringName] = context["reason_trace"].duplicate()
|
||||
reason_trace.append(reason_id)
|
||||
return ConversationTurn.new(
|
||||
conversation_id, revision, speaker, listener, act, options, topics, reason_trace, terminal
|
||||
)
|
||||
|
||||
|
||||
func _option_intents_for(intent_id: StringName, context: Dictionary) -> Array[StringName]:
|
||||
var overrides: Dictionary = context["option_intent_ids"]
|
||||
if overrides.has(intent_id):
|
||||
return (overrides[intent_id] as Array).duplicate()
|
||||
return _catalog.get_response_intent_ids(intent_id)
|
||||
|
||||
|
||||
func _topics_for_intent(intent_id: StringName, context: Dictionary) -> Array[StringName]:
|
||||
var topics_by_intent: Dictionary = context["topics_by_intent"]
|
||||
if topics_by_intent.has(intent_id):
|
||||
return (topics_by_intent[intent_id] as Array).duplicate()
|
||||
return (context["topic_ids"] as Array).duplicate()
|
||||
|
||||
|
||||
func _normalize_context(context: Dictionary) -> Variant:
|
||||
for key in context:
|
||||
if (key is not String and key is not StringName) or String(key) not in CONTEXT_KEYS:
|
||||
return null
|
||||
var raw_initial_intent: Variant = context.get("initial_intent_id", ConversationIntentIds.GREET)
|
||||
if not ConversationSemantic.is_valid_id(raw_initial_intent):
|
||||
return null
|
||||
var initial_intent := StringName(raw_initial_intent)
|
||||
if _catalog == null or not _catalog.has_intent(initial_intent):
|
||||
return null
|
||||
var raw_conversation_key: Variant = context.get("conversation_key", "default")
|
||||
if not ConversationSemantic.is_valid_id(raw_conversation_key):
|
||||
return null
|
||||
var conversation_key := StringName(raw_conversation_key)
|
||||
var topic_ids: Variant = ConversationSemantic.normalize_id_array(context.get("topic_ids", []))
|
||||
var blocked: Variant = ConversationSemantic.normalize_id_array(
|
||||
context.get("blocked_intent_ids", [])
|
||||
)
|
||||
var reason_trace: Variant = ConversationSemantic.normalize_trace(
|
||||
context.get("reason_trace", [])
|
||||
)
|
||||
if topic_ids == null or blocked == null or reason_trace == null:
|
||||
return null
|
||||
for blocked_id in blocked:
|
||||
if not _catalog.has_intent(blocked_id):
|
||||
return null
|
||||
var normalized_options: Variant = _normalize_intent_map(
|
||||
context.get("option_intent_ids", {}), true
|
||||
)
|
||||
var normalized_topics: Variant = _normalize_intent_map(
|
||||
context.get("topics_by_intent", {}), false
|
||||
)
|
||||
var normalized_block_reasons: Variant = _normalize_reason_map(
|
||||
context.get("block_reason_by_intent", {})
|
||||
)
|
||||
if normalized_options == null or normalized_topics == null or normalized_block_reasons == null:
|
||||
return null
|
||||
return {
|
||||
"conversation_key": conversation_key,
|
||||
"initial_intent_id": initial_intent,
|
||||
"topic_ids": topic_ids,
|
||||
"option_intent_ids": normalized_options,
|
||||
"topics_by_intent": normalized_topics,
|
||||
"blocked_intent_ids": blocked,
|
||||
"block_reason_by_intent": normalized_block_reasons,
|
||||
"reason_trace": reason_trace,
|
||||
}
|
||||
|
||||
|
||||
func _normalize_intent_map(value: Variant, values_are_intents: bool) -> Variant:
|
||||
if value is not Dictionary:
|
||||
return null
|
||||
var normalized: Dictionary = {}
|
||||
for raw_key in value:
|
||||
if not ConversationSemantic.is_valid_id(raw_key):
|
||||
return null
|
||||
var intent_id := StringName(raw_key)
|
||||
if not _catalog.has_intent(intent_id):
|
||||
return null
|
||||
var ids: Variant = ConversationSemantic.normalize_id_array(value[raw_key])
|
||||
if ids == null:
|
||||
return null
|
||||
if values_are_intents:
|
||||
for semantic_id in ids:
|
||||
if not _catalog.has_intent(semantic_id):
|
||||
return null
|
||||
normalized[intent_id] = ids
|
||||
return normalized
|
||||
|
||||
|
||||
func _normalize_reason_map(value: Variant) -> Variant:
|
||||
if value is not Dictionary:
|
||||
return null
|
||||
var normalized: Dictionary = {}
|
||||
for raw_key in value:
|
||||
if not ConversationSemantic.is_valid_id(raw_key):
|
||||
return null
|
||||
var intent_id := StringName(raw_key)
|
||||
if not ConversationSemantic.is_valid_id(value[raw_key]):
|
||||
return null
|
||||
var reason_id := StringName(value[raw_key])
|
||||
if not _catalog.has_intent(intent_id):
|
||||
return null
|
||||
normalized[intent_id] = reason_id
|
||||
return normalized
|
||||
|
||||
|
||||
func _make_conversation_id(
|
||||
speaker: WorldEntityRef, listener: WorldEntityRef, context: Dictionary
|
||||
) -> StringName:
|
||||
var sequence := _next_sequence
|
||||
_next_sequence += 1
|
||||
var parts := [
|
||||
speaker.index_key(),
|
||||
listener.index_key(),
|
||||
String(context["conversation_key"]),
|
||||
str(sequence),
|
||||
]
|
||||
var digest := ("|".join(parts)).sha256_text().substr(0, 16)
|
||||
return StringName("conversation_%08d_%s" % [sequence, digest])
|
||||
|
||||
|
||||
func _participants_are_valid(speaker: WorldEntityRef, listener: WorldEntityRef) -> bool:
|
||||
return (
|
||||
speaker != null
|
||||
and speaker.is_valid()
|
||||
and listener != null
|
||||
and listener.is_valid()
|
||||
and not speaker.equals(listener)
|
||||
)
|
||||
|
||||
|
||||
func _rejected(
|
||||
reason_code: StringName,
|
||||
expected_revision: int,
|
||||
current_revision: int,
|
||||
option_id: StringName,
|
||||
turn: ConversationTurn,
|
||||
reason_trace: Array[StringName]
|
||||
) -> ConversationSelectionResult:
|
||||
return ConversationSelectionResult.new(
|
||||
false, reason_code, expected_revision, current_revision, option_id, turn, reason_trace
|
||||
)
|
||||
Reference in New Issue
Block a user