refactor: split large modules and normalize rust layout

server-rs/crates/spacetime-client/src/mapper/ai.rs

@@ -0,0 +1,306 @@
+use super::*;
+
+use crate::mapper::{
+    custom_world::{format_ai_result_reference_kind, format_ai_task_kind},
+    inventory::map_ai_result_reference_kind,
+    npc::map_ai_task_kind,
+};
+
+impl From<DomainAiTaskCreateInput> for AiTaskCreateInput {
+    fn from(input: DomainAiTaskCreateInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            task_kind: map_ai_task_kind(input.task_kind),
+            owner_user_id: input.owner_user_id,
+            request_label: input.request_label,
+            source_module: input.source_module,
+            source_entity_id: input.source_entity_id,
+            request_payload_json: input.request_payload_json,
+            stages: input.stages.into_iter().map(Into::into).collect(),
+            created_at_micros: input.created_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiTaskStartInput> for AiTaskStartInput {
+    fn from(input: DomainAiTaskStartInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            started_at_micros: input.started_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiTaskStageStartInput> for AiTaskStageStartInput {
+    fn from(input: DomainAiTaskStageStartInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            stage_kind: map_ai_task_stage_kind(input.stage_kind),
+            started_at_micros: input.started_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiTextChunkAppendInput> for AiTextChunkAppendInput {
+    fn from(input: DomainAiTextChunkAppendInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            stage_kind: map_ai_task_stage_kind(input.stage_kind),
+            sequence: input.sequence,
+            delta_text: input.delta_text,
+            created_at_micros: input.created_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiStageCompletionInput> for AiStageCompletionInput {
+    fn from(input: DomainAiStageCompletionInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            stage_kind: map_ai_task_stage_kind(input.stage_kind),
+            text_output: input.text_output,
+            structured_payload_json: input.structured_payload_json,
+            warning_messages: input.warning_messages,
+            completed_at_micros: input.completed_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiResultReferenceInput> for AiResultReferenceInput {
+    fn from(input: DomainAiResultReferenceInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            reference_kind: map_ai_result_reference_kind(input.reference_kind),
+            reference_id: input.reference_id,
+            label: input.label,
+            created_at_micros: input.created_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiTaskFinishInput> for AiTaskFinishInput {
+    fn from(input: DomainAiTaskFinishInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            completed_at_micros: input.completed_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiTaskFailureInput> for AiTaskFailureInput {
+    fn from(input: DomainAiTaskFailureInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            failure_message: input.failure_message,
+            completed_at_micros: input.completed_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiTaskCancelInput> for AiTaskCancelInput {
+    fn from(input: DomainAiTaskCancelInput) -> Self {
+        Self {
+            task_id: input.task_id,
+            completed_at_micros: input.completed_at_micros,
+        }
+    }
+}
+
+impl From<DomainAiTaskStageBlueprint> for AiTaskStageBlueprint {
+    fn from(blueprint: DomainAiTaskStageBlueprint) -> Self {
+        Self {
+            stage_kind: map_ai_task_stage_kind(blueprint.stage_kind),
+            label: blueprint.label,
+            detail: blueprint.detail,
+            order: blueprint.order,
+        }
+    }
+}
+
+pub(crate) fn map_ai_task_procedure_result(
+    result: AiTaskProcedureResult,
+) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+
+    let task = result
+        .task
+        .ok_or_else(|| SpacetimeClientError::missing_snapshot("ai_task 快照"))?;
+
+    Ok(AiTaskMutationRecord {
+        task: map_ai_task_snapshot(task),
+        text_chunk: result.text_chunk.map(map_ai_text_chunk_snapshot),
+    })
+}
+
+pub(crate) fn map_ai_task_snapshot(snapshot: AiTaskSnapshot) -> AiTaskRecord {
+    AiTaskRecord {
+        task_id: snapshot.task_id,
+        task_kind: format_ai_task_kind(snapshot.task_kind).to_string(),
+        owner_user_id: snapshot.owner_user_id,
+        request_label: snapshot.request_label,
+        source_module: snapshot.source_module,
+        source_entity_id: snapshot.source_entity_id,
+        request_payload_json: snapshot.request_payload_json,
+        status: format_ai_task_status(snapshot.status).to_string(),
+        failure_message: snapshot.failure_message,
+        stages: snapshot
+            .stages
+            .into_iter()
+            .map(map_ai_task_stage_snapshot)
+            .collect(),
+        result_references: snapshot
+            .result_references
+            .into_iter()
+            .map(map_ai_result_reference_snapshot)
+            .collect(),
+        latest_text_output: snapshot.latest_text_output,
+        latest_structured_payload_json: snapshot.latest_structured_payload_json,
+        version: snapshot.version,
+        created_at: format_timestamp_micros(snapshot.created_at_micros),
+        started_at: snapshot.started_at_micros.map(format_timestamp_micros),
+        completed_at: snapshot.completed_at_micros.map(format_timestamp_micros),
+        updated_at: format_timestamp_micros(snapshot.updated_at_micros),
+    }
+}
+
+pub(crate) fn map_ai_task_stage_snapshot(snapshot: AiTaskStageSnapshot) -> AiTaskStageRecord {
+    AiTaskStageRecord {
+        stage_kind: format_ai_task_stage_kind(snapshot.stage_kind).to_string(),
+        label: snapshot.label,
+        detail: snapshot.detail,
+        order: snapshot.order,
+        status: format_ai_task_stage_status(snapshot.status).to_string(),
+        text_output: snapshot.text_output,
+        structured_payload_json: snapshot.structured_payload_json,
+        warning_messages: snapshot.warning_messages,
+        started_at: snapshot.started_at_micros.map(format_timestamp_micros),
+        completed_at: snapshot.completed_at_micros.map(format_timestamp_micros),
+    }
+}
+
+pub(crate) fn map_ai_text_chunk_snapshot(snapshot: AiTextChunkSnapshot) -> AiTextChunkRecord {
+    AiTextChunkRecord {
+        chunk_id: snapshot.chunk_id,
+        task_id: snapshot.task_id,
+        stage_kind: format_ai_task_stage_kind(snapshot.stage_kind).to_string(),
+        sequence: snapshot.sequence,
+        delta_text: snapshot.delta_text,
+        created_at: format_timestamp_micros(snapshot.created_at_micros),
+    }
+}
+
+pub(crate) fn map_ai_result_reference_snapshot(
+    snapshot: AiResultReferenceSnapshot,
+) -> AiResultReferenceRecord {
+    AiResultReferenceRecord {
+        result_ref_id: snapshot.result_ref_id,
+        task_id: snapshot.task_id,
+        reference_kind: format_ai_result_reference_kind(snapshot.reference_kind).to_string(),
+        reference_id: snapshot.reference_id,
+        label: snapshot.label,
+        created_at: format_timestamp_micros(snapshot.created_at_micros),
+    }
+}
+
+pub(crate) fn map_ai_task_stage_kind(value: DomainAiTaskStageKind) -> AiTaskStageKind {
+    match value {
+        DomainAiTaskStageKind::PreparePrompt => AiTaskStageKind::PreparePrompt,
+        DomainAiTaskStageKind::RequestModel => AiTaskStageKind::RequestModel,
+        DomainAiTaskStageKind::RepairResponse => AiTaskStageKind::RepairResponse,
+        DomainAiTaskStageKind::NormalizeResult => AiTaskStageKind::NormalizeResult,
+        DomainAiTaskStageKind::PersistResult => AiTaskStageKind::PersistResult,
+    }
+}
+
+pub(crate) fn format_ai_task_status(value: AiTaskStatus) -> &'static str {
+    match value {
+        AiTaskStatus::Pending => "pending",
+        AiTaskStatus::Running => "running",
+        AiTaskStatus::Completed => "completed",
+        AiTaskStatus::Failed => "failed",
+        AiTaskStatus::Cancelled => "cancelled",
+    }
+}
+
+pub(crate) fn format_ai_task_stage_kind(value: AiTaskStageKind) -> &'static str {
+    match value {
+        AiTaskStageKind::PreparePrompt => "prepare_prompt",
+        AiTaskStageKind::RequestModel => "request_model",
+        AiTaskStageKind::RepairResponse => "repair_response",
+        AiTaskStageKind::NormalizeResult => "normalize_result",
+        AiTaskStageKind::PersistResult => "persist_result",
+    }
+}
+
+pub(crate) fn format_ai_task_stage_status(value: AiTaskStageStatus) -> &'static str {
+    match value {
+        AiTaskStageStatus::Pending => "pending",
+        AiTaskStageStatus::Running => "running",
+        AiTaskStageStatus::Completed => "completed",
+        AiTaskStageStatus::Skipped => "skipped",
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AiTaskStageRecord {
+    pub stage_kind: String,
+    pub label: String,
+    pub detail: String,
+    pub order: u32,
+    pub status: String,
+    pub text_output: Option<String>,
+    pub structured_payload_json: Option<String>,
+    pub warning_messages: Vec<String>,
+    pub started_at: Option<String>,
+    pub completed_at: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AiResultReferenceRecord {
+    pub result_ref_id: String,
+    pub task_id: String,
+    pub reference_kind: String,
+    pub reference_id: String,
+    pub label: Option<String>,
+    pub created_at: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AiTextChunkRecord {
+    pub chunk_id: String,
+    pub task_id: String,
+    pub stage_kind: String,
+    pub sequence: u32,
+    pub delta_text: String,
+    pub created_at: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AiTaskRecord {
+    pub task_id: String,
+    pub task_kind: String,
+    pub owner_user_id: String,
+    pub request_label: String,
+    pub source_module: String,
+    pub source_entity_id: Option<String>,
+    pub request_payload_json: Option<String>,
+    pub status: String,
+    pub failure_message: Option<String>,
+    pub stages: Vec<AiTaskStageRecord>,
+    pub result_references: Vec<AiResultReferenceRecord>,
+    pub latest_text_output: Option<String>,
+    pub latest_structured_payload_json: Option<String>,
+    pub version: u32,
+    pub created_at: String,
+    pub started_at: Option<String>,
+    pub completed_at: Option<String>,
+    pub updated_at: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AiTaskMutationRecord {
+    pub task: AiTaskRecord,
+    pub text_chunk: Option<AiTextChunkRecord>,
+}