745 lines
23 KiB
Python
745 lines
23 KiB
Python
"""Voice co-creation session service."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from fastapi import HTTPException
|
|
from sqlalchemy import desc, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.core.logging import get_logger
|
|
from app.db.models import VoiceSession, VoiceSessionEvent, VoiceTurn
|
|
from app.schemas.voice_session_schemas import (
|
|
VoiceSessionAbandonRequest,
|
|
VoiceSessionCreateRequest,
|
|
VoiceSessionDetailResponse,
|
|
VoiceSessionFinalizeRequest,
|
|
VoiceSessionFinalizeResponse,
|
|
VoiceSessionSummaryResponse,
|
|
VoiceTurnAcceptedResponse,
|
|
VoiceTurnCreateFallbackRequest,
|
|
VoiceTurnSummaryResponse,
|
|
)
|
|
from app.services.adapters.text.models import StoryOutput
|
|
from app.services.memory_service import build_enhanced_memory_context
|
|
from app.services.provider_router import generate_story_content, text_to_speech
|
|
from app.services.story_service import (
|
|
create_story_from_result,
|
|
validate_profile_and_universe,
|
|
)
|
|
from app.services.voice_session_storage import (
|
|
build_turn_assistant_audio_path,
|
|
read_session_audio,
|
|
session_audio_exists,
|
|
write_session_audio,
|
|
)
|
|
|
|
logger = get_logger(__name__)
|
|
|
|
ACTIVE_SESSION_STATUSES = {"draft", "active", "processing_turn", "waiting_user"}
|
|
CONTINUABLE_SESSION_STATUSES = {"draft", "active", "waiting_user"}
|
|
FINAL_SESSION_STATUSES = {"completed", "abandoned"}
|
|
|
|
|
|
def _default_story_state() -> dict[str, Any]:
|
|
return {
|
|
"premise": None,
|
|
"latest_direction": None,
|
|
"cover_prompt": None,
|
|
"narrative_segments": [],
|
|
"safety_flags": [],
|
|
"last_intent": None,
|
|
}
|
|
|
|
|
|
def _session_can_continue(session: VoiceSession) -> bool:
|
|
return session.status in CONTINUABLE_SESSION_STATUSES
|
|
|
|
|
|
def _session_can_finalize(session: VoiceSession) -> bool:
|
|
segments = list((session.story_state or {}).get("narrative_segments") or [])
|
|
return bool(segments) and session.status in {"active", "waiting_user"}
|
|
|
|
|
|
def _assistant_audio_url(session_id: str, turn_id: str, audio_path: str | None) -> str | None:
|
|
if not session_audio_exists(audio_path):
|
|
return None
|
|
return f"/api/voice-sessions/{session_id}/turns/{turn_id}/audio"
|
|
|
|
|
|
def _turn_to_summary(turn: VoiceTurn) -> VoiceTurnSummaryResponse:
|
|
return VoiceTurnSummaryResponse(
|
|
id=turn.id,
|
|
session_id=turn.session_id,
|
|
turn_index=turn.turn_index,
|
|
status=turn.status,
|
|
user_transcript=turn.user_transcript,
|
|
transcript_confidence=turn.transcript_confidence,
|
|
detected_intent=turn.detected_intent,
|
|
intent_confidence=turn.intent_confidence,
|
|
assistant_text=turn.assistant_text,
|
|
assistant_audio_ready=session_audio_exists(turn.assistant_audio_path),
|
|
assistant_audio_url=_assistant_audio_url(
|
|
turn.session_id,
|
|
turn.id,
|
|
turn.assistant_audio_path,
|
|
),
|
|
error_message=turn.error_message,
|
|
created_at=turn.created_at,
|
|
updated_at=turn.updated_at,
|
|
)
|
|
|
|
|
|
def _session_to_summary(session: VoiceSession) -> VoiceSessionSummaryResponse:
|
|
return VoiceSessionSummaryResponse(
|
|
id=session.id,
|
|
child_profile_id=session.child_profile_id,
|
|
universe_id=session.universe_id,
|
|
final_story_id=session.final_story_id,
|
|
target_mode=session.target_mode,
|
|
status=session.status,
|
|
current_turn_index=session.current_turn_index,
|
|
working_title=session.working_title,
|
|
story_state=session.story_state or {},
|
|
latest_user_transcript=session.latest_user_transcript,
|
|
latest_assistant_text=session.latest_assistant_text,
|
|
can_continue=_session_can_continue(session),
|
|
can_finalize=_session_can_finalize(session),
|
|
last_error=session.last_error,
|
|
created_at=session.created_at,
|
|
updated_at=session.updated_at,
|
|
)
|
|
|
|
|
|
async def _record_session_event(
|
|
db: AsyncSession,
|
|
*,
|
|
session_id: str,
|
|
turn_id: str | None,
|
|
event_type: str,
|
|
status: str,
|
|
message: str | None = None,
|
|
metadata: dict[str, Any] | None = None,
|
|
) -> VoiceSessionEvent:
|
|
event = VoiceSessionEvent(
|
|
session_id=session_id,
|
|
turn_id=turn_id,
|
|
event_type=event_type,
|
|
status=status,
|
|
message=message,
|
|
event_metadata=metadata or {},
|
|
)
|
|
db.add(event)
|
|
await db.commit()
|
|
await db.refresh(event)
|
|
return event
|
|
|
|
|
|
async def _get_owned_session(
|
|
db: AsyncSession,
|
|
*,
|
|
session_id: str,
|
|
user_id: str,
|
|
) -> VoiceSession:
|
|
result = await db.execute(
|
|
select(VoiceSession).where(
|
|
VoiceSession.id == session_id,
|
|
VoiceSession.user_id == user_id,
|
|
)
|
|
)
|
|
session = result.scalar_one_or_none()
|
|
if not session:
|
|
raise HTTPException(status_code=404, detail="Voice session not found")
|
|
return session
|
|
|
|
|
|
async def _get_owned_turn(
|
|
db: AsyncSession,
|
|
*,
|
|
session_id: str,
|
|
turn_id: str,
|
|
user_id: str,
|
|
) -> VoiceTurn:
|
|
result = await db.execute(
|
|
select(VoiceTurn)
|
|
.join(VoiceSession, VoiceTurn.session_id == VoiceSession.id)
|
|
.where(
|
|
VoiceTurn.id == turn_id,
|
|
VoiceTurn.session_id == session_id,
|
|
VoiceSession.user_id == user_id,
|
|
)
|
|
)
|
|
turn = result.scalar_one_or_none()
|
|
if not turn:
|
|
raise HTTPException(status_code=404, detail="Voice turn not found")
|
|
return turn
|
|
|
|
|
|
def _detect_intent(
|
|
transcript_text: str,
|
|
*,
|
|
current_turn_index: int,
|
|
) -> tuple[str, float]:
|
|
normalized = transcript_text.replace(" ", "")
|
|
|
|
if any(keyword in normalized for keyword in ("保存故事", "存起来", "保存吧", "保存到故事库")):
|
|
return "save_story", 0.95
|
|
if any(keyword in normalized for keyword in ("先到这里", "讲完了", "结束吧", "停在这里")):
|
|
return "end_story", 0.88
|
|
if current_turn_index == 0:
|
|
return "start_story", 0.82
|
|
if any(
|
|
keyword in normalized
|
|
for keyword in (
|
|
"不要",
|
|
"改成",
|
|
"换成",
|
|
"我想让",
|
|
"让它",
|
|
"改一下",
|
|
"改一改",
|
|
"其实",
|
|
)
|
|
):
|
|
return "correct_story", 0.76
|
|
return "continue_story", 0.68
|
|
|
|
|
|
def _recent_story_text(session: VoiceSession) -> str:
|
|
story_state = session.story_state or {}
|
|
segments = list(story_state.get("narrative_segments") or [])
|
|
if not segments:
|
|
return ""
|
|
return "\n\n".join(segments[-2:])
|
|
|
|
|
|
def _build_generation_prompt(
|
|
*,
|
|
session: VoiceSession,
|
|
transcript_text: str,
|
|
intent: str,
|
|
) -> str:
|
|
recent_story = _recent_story_text(session)
|
|
|
|
if intent == "start_story":
|
|
return (
|
|
"你是 DreamWeaver 的儿童故事共创助手。"
|
|
"请为 3-8 岁儿童写一个温暖、安全、适合继续接龙的故事开头。"
|
|
f"孩子刚刚说：{transcript_text}。"
|
|
"请只输出一小段自然的中文故事，不要分点，不要解释，不要写“故事开始”。"
|
|
)
|
|
|
|
if intent == "correct_story":
|
|
return (
|
|
"你是 DreamWeaver 的儿童故事共创助手。"
|
|
f"当前故事最近两段如下：{recent_story or '（暂时还没有已讲述内容）'}。"
|
|
f"孩子希望修正故事走向：{transcript_text}。"
|
|
"请顺着已有内容自然接住这个修改，继续写一小段新故事。"
|
|
"不要从头重讲，不要解释规则。"
|
|
)
|
|
|
|
return (
|
|
"你是 DreamWeaver 的儿童故事共创助手。"
|
|
f"当前故事最近两段如下：{recent_story or '（暂时还没有已讲述内容）'}。"
|
|
f"孩子接着说：{transcript_text}。"
|
|
"请继续写一小段新的儿童故事内容，让故事自然往下发展。"
|
|
"不要分点，不要做旁白说明。"
|
|
)
|
|
|
|
|
|
async def _generate_assistant_turn(
|
|
db: AsyncSession,
|
|
*,
|
|
session: VoiceSession,
|
|
transcript_text: str,
|
|
intent: str,
|
|
) -> StoryOutput:
|
|
memory_context = await build_enhanced_memory_context(
|
|
session.child_profile_id,
|
|
session.universe_id,
|
|
db,
|
|
)
|
|
prompt = _build_generation_prompt(
|
|
session=session,
|
|
transcript_text=transcript_text,
|
|
intent=intent,
|
|
)
|
|
return await generate_story_content(
|
|
input_type="full_story",
|
|
data=prompt,
|
|
memory_context=memory_context,
|
|
db=db,
|
|
user_id=session.user_id,
|
|
)
|
|
|
|
|
|
def _merge_story_state(
|
|
session: VoiceSession,
|
|
*,
|
|
transcript_text: str,
|
|
intent: str,
|
|
assistant_result: StoryOutput | None,
|
|
) -> tuple[dict[str, Any], dict[str, Any]]:
|
|
current_state = _default_story_state() | (session.story_state or {})
|
|
narrative_segments = list(current_state.get("narrative_segments") or [])
|
|
|
|
if intent == "start_story" and not current_state.get("premise"):
|
|
current_state["premise"] = transcript_text
|
|
|
|
if assistant_result and assistant_result.story_text:
|
|
narrative_segments.append(assistant_result.story_text.strip())
|
|
|
|
current_state["narrative_segments"] = narrative_segments
|
|
current_state["latest_direction"] = transcript_text
|
|
current_state["last_intent"] = intent
|
|
if assistant_result and assistant_result.cover_prompt_suggestion:
|
|
current_state["cover_prompt"] = assistant_result.cover_prompt_suggestion
|
|
|
|
patch = {
|
|
"intent": intent,
|
|
"transcript_text": transcript_text,
|
|
"segment_added": bool(assistant_result and assistant_result.story_text),
|
|
"working_title": assistant_result.title if assistant_result else session.working_title,
|
|
"cover_prompt": current_state.get("cover_prompt"),
|
|
"narrative_segments_count": len(narrative_segments),
|
|
}
|
|
return current_state, patch
|
|
|
|
|
|
async def create_voice_session_service(
|
|
request: VoiceSessionCreateRequest,
|
|
user_id: str,
|
|
db: AsyncSession,
|
|
) -> VoiceSessionSummaryResponse:
|
|
profile_id, universe_id = await validate_profile_and_universe(
|
|
request.child_profile_id,
|
|
request.universe_id,
|
|
user_id,
|
|
db,
|
|
)
|
|
|
|
session = VoiceSession(
|
|
user_id=user_id,
|
|
child_profile_id=profile_id,
|
|
universe_id=universe_id,
|
|
target_mode=request.target_mode,
|
|
status="draft",
|
|
story_state=_default_story_state(),
|
|
)
|
|
db.add(session)
|
|
await db.commit()
|
|
await db.refresh(session)
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=None,
|
|
event_type="session_created",
|
|
status="succeeded",
|
|
message="Voice co-creation session created.",
|
|
metadata={
|
|
"child_profile_id": session.child_profile_id,
|
|
"universe_id": session.universe_id,
|
|
"target_mode": session.target_mode,
|
|
},
|
|
)
|
|
await db.refresh(session)
|
|
return _session_to_summary(session)
|
|
|
|
|
|
async def get_voice_session_detail_service(
|
|
session_id: str,
|
|
user_id: str,
|
|
db: AsyncSession,
|
|
) -> VoiceSessionDetailResponse:
|
|
session = await _get_owned_session(db, session_id=session_id, user_id=user_id)
|
|
turns = (
|
|
await db.execute(
|
|
select(VoiceTurn)
|
|
.where(VoiceTurn.session_id == session.id)
|
|
.order_by(desc(VoiceTurn.turn_index))
|
|
.limit(10)
|
|
)
|
|
).scalars().all()
|
|
turns = list(reversed(turns))
|
|
|
|
events = (
|
|
await db.execute(
|
|
select(VoiceSessionEvent)
|
|
.where(VoiceSessionEvent.session_id == session.id)
|
|
.order_by(desc(VoiceSessionEvent.id))
|
|
.limit(50)
|
|
)
|
|
).scalars().all()
|
|
events = list(reversed(events))
|
|
|
|
summary = _session_to_summary(session)
|
|
return VoiceSessionDetailResponse(
|
|
**summary.model_dump(),
|
|
recent_turns=[_turn_to_summary(turn) for turn in turns],
|
|
events=[
|
|
{
|
|
"id": event.id,
|
|
"session_id": event.session_id,
|
|
"turn_id": event.turn_id,
|
|
"event_type": event.event_type,
|
|
"status": event.status,
|
|
"message": event.message,
|
|
"event_metadata": event.event_metadata or {},
|
|
"created_at": event.created_at,
|
|
}
|
|
for event in events
|
|
],
|
|
)
|
|
|
|
|
|
async def create_voice_turn_from_text_service(
|
|
session_id: str,
|
|
request: VoiceTurnCreateFallbackRequest,
|
|
user_id: str,
|
|
db: AsyncSession,
|
|
) -> VoiceTurnAcceptedResponse:
|
|
session = await _get_owned_session(db, session_id=session_id, user_id=user_id)
|
|
if session.status not in CONTINUABLE_SESSION_STATUSES:
|
|
raise HTTPException(
|
|
status_code=409,
|
|
detail="Voice session is not ready for another turn.",
|
|
)
|
|
|
|
transcript_text = request.transcript_text.strip()
|
|
next_turn_index = session.current_turn_index + 1
|
|
detected_intent, intent_confidence = _detect_intent(
|
|
transcript_text,
|
|
current_turn_index=session.current_turn_index,
|
|
)
|
|
|
|
turn = VoiceTurn(
|
|
session_id=session.id,
|
|
turn_index=next_turn_index,
|
|
status="transcribing",
|
|
user_audio_duration_ms=request.duration_ms,
|
|
user_transcript=transcript_text,
|
|
transcript_confidence=1.0,
|
|
detected_intent=detected_intent,
|
|
intent_confidence=intent_confidence,
|
|
)
|
|
session.status = "processing_turn"
|
|
session.current_turn_index = next_turn_index
|
|
session.latest_user_transcript = transcript_text
|
|
session.last_error = None
|
|
db.add(turn)
|
|
await db.commit()
|
|
await db.refresh(session)
|
|
await db.refresh(turn)
|
|
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="turn_received",
|
|
status="received",
|
|
message="Voice turn fallback text received.",
|
|
metadata={"turn_index": turn.turn_index},
|
|
)
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="turn_transcribed",
|
|
status="succeeded",
|
|
message="Fallback transcript accepted.",
|
|
metadata={"transcript_confidence": turn.transcript_confidence},
|
|
)
|
|
|
|
assistant_text: str | None = None
|
|
assistant_result: StoryOutput | None = None
|
|
|
|
try:
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="intent_resolved",
|
|
status="succeeded",
|
|
message="Turn intent resolved.",
|
|
metadata={
|
|
"detected_intent": detected_intent,
|
|
"intent_confidence": intent_confidence,
|
|
},
|
|
)
|
|
|
|
if detected_intent == "save_story":
|
|
assistant_text = "好的，这个故事已经准备好保存到故事库了。"
|
|
elif detected_intent == "end_story":
|
|
assistant_text = "好的，我们先把故事停在这里。想保存的话，现在就可以保存到故事库。"
|
|
else:
|
|
assistant_result = await _generate_assistant_turn(
|
|
db,
|
|
session=session,
|
|
transcript_text=transcript_text,
|
|
intent=detected_intent,
|
|
)
|
|
assistant_text = assistant_result.story_text.strip()
|
|
|
|
merged_state, story_patch = _merge_story_state(
|
|
session,
|
|
transcript_text=transcript_text,
|
|
intent=detected_intent,
|
|
assistant_result=assistant_result,
|
|
)
|
|
turn.story_patch = story_patch
|
|
turn.assistant_text = assistant_text
|
|
turn.status = "narrative_ready"
|
|
session.story_state = merged_state
|
|
session.latest_assistant_text = assistant_text
|
|
session.status = "waiting_user"
|
|
if assistant_result and assistant_result.title and not session.working_title:
|
|
session.working_title = assistant_result.title
|
|
await db.commit()
|
|
await db.refresh(session)
|
|
await db.refresh(turn)
|
|
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="story_patch_applied",
|
|
status="succeeded",
|
|
message="Story state updated after one turn.",
|
|
metadata=story_patch,
|
|
)
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="assistant_text_ready",
|
|
status="succeeded",
|
|
message="Assistant text response generated.",
|
|
metadata={
|
|
"assistant_text_length": len(assistant_text or ""),
|
|
"working_title": session.working_title,
|
|
},
|
|
)
|
|
except Exception as exc:
|
|
turn.status = "failed"
|
|
turn.error_message = str(exc)
|
|
session.status = "waiting_user"
|
|
session.last_error = str(exc)
|
|
await db.commit()
|
|
await db.refresh(session)
|
|
await db.refresh(turn)
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="session_failed",
|
|
status="failed",
|
|
message="Assistant narrative generation failed for one voice turn.",
|
|
metadata={"error": str(exc), "turn_index": turn.turn_index},
|
|
)
|
|
logger.warning(
|
|
"voice_turn_generation_failed",
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
error=str(exc),
|
|
)
|
|
return VoiceTurnAcceptedResponse(
|
|
turn_id=turn.id,
|
|
session_id=session.id,
|
|
status=turn.status,
|
|
)
|
|
|
|
if assistant_text:
|
|
try:
|
|
audio_bytes = await text_to_speech(
|
|
assistant_text,
|
|
db=db,
|
|
user_id=user_id,
|
|
)
|
|
saved_path = write_session_audio(
|
|
build_turn_assistant_audio_path(session.id, turn.turn_index),
|
|
audio_bytes,
|
|
)
|
|
turn.assistant_audio_path = saved_path
|
|
turn.assistant_audio_duration_ms = None
|
|
turn.status = "audio_ready"
|
|
await db.commit()
|
|
await db.refresh(turn)
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="assistant_audio_ready",
|
|
status="succeeded",
|
|
message="Assistant audio response generated.",
|
|
metadata={"audio_path": saved_path},
|
|
)
|
|
except Exception as exc:
|
|
turn.status = "narrative_ready"
|
|
turn.error_message = None
|
|
session.last_error = None
|
|
await db.commit()
|
|
await db.refresh(turn)
|
|
await db.refresh(session)
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
event_type="assistant_audio_failed",
|
|
status="failed",
|
|
message="Assistant audio generation failed, text response kept.",
|
|
metadata={"error": str(exc)},
|
|
)
|
|
logger.warning(
|
|
"voice_turn_audio_failed",
|
|
session_id=session.id,
|
|
turn_id=turn.id,
|
|
error=str(exc),
|
|
)
|
|
|
|
return VoiceTurnAcceptedResponse(
|
|
turn_id=turn.id,
|
|
session_id=session.id,
|
|
status=turn.status,
|
|
)
|
|
|
|
|
|
async def get_voice_turn_service(
|
|
session_id: str,
|
|
turn_id: str,
|
|
user_id: str,
|
|
db: AsyncSession,
|
|
) -> VoiceTurnSummaryResponse:
|
|
turn = await _get_owned_turn(
|
|
db,
|
|
session_id=session_id,
|
|
turn_id=turn_id,
|
|
user_id=user_id,
|
|
)
|
|
return _turn_to_summary(turn)
|
|
|
|
|
|
async def get_voice_turn_audio_service(
|
|
session_id: str,
|
|
turn_id: str,
|
|
user_id: str,
|
|
db: AsyncSession,
|
|
) -> bytes:
|
|
turn = await _get_owned_turn(
|
|
db,
|
|
session_id=session_id,
|
|
turn_id=turn_id,
|
|
user_id=user_id,
|
|
)
|
|
if not session_audio_exists(turn.assistant_audio_path):
|
|
raise HTTPException(status_code=404, detail="Voice turn audio not found")
|
|
return read_session_audio(turn.assistant_audio_path)
|
|
|
|
|
|
async def finalize_voice_session_service(
|
|
session_id: str,
|
|
request: VoiceSessionFinalizeRequest,
|
|
user_id: str,
|
|
db: AsyncSession,
|
|
) -> VoiceSessionFinalizeResponse:
|
|
if not request.save_story:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Voice session finalize requires save_story=true in Phase A.",
|
|
)
|
|
|
|
session = await _get_owned_session(db, session_id=session_id, user_id=user_id)
|
|
if session.status in FINAL_SESSION_STATUSES:
|
|
raise HTTPException(status_code=409, detail="Voice session is already closed.")
|
|
if not _session_can_finalize(session):
|
|
raise HTTPException(status_code=409, detail="Voice session is not ready to finalize.")
|
|
|
|
session.status = "finalizing_story"
|
|
await db.commit()
|
|
await db.refresh(session)
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=None,
|
|
event_type="session_finalizing",
|
|
status="running",
|
|
message="Voice session is being finalized into a story.",
|
|
metadata={"generate_cover": request.generate_cover},
|
|
)
|
|
|
|
story_state = session.story_state or {}
|
|
narrative_segments = list(story_state.get("narrative_segments") or [])
|
|
final_story_text = "\n\n".join(
|
|
segment.strip() for segment in narrative_segments if segment.strip()
|
|
)
|
|
if not final_story_text:
|
|
raise HTTPException(status_code=409, detail="Voice session has no narrative to save.")
|
|
|
|
story_result = StoryOutput(
|
|
mode="generated",
|
|
title=session.working_title or "一起编织的睡前故事",
|
|
story_text=final_story_text,
|
|
cover_prompt_suggestion=(
|
|
(story_state.get("cover_prompt") or "") if request.generate_cover else ""
|
|
),
|
|
)
|
|
|
|
story = await create_story_from_result(
|
|
result=story_result,
|
|
user_id=user_id,
|
|
profile_id=session.child_profile_id,
|
|
universe_id=session.universe_id,
|
|
db=db,
|
|
)
|
|
|
|
session.final_story_id = story.id
|
|
session.status = "completed"
|
|
session.last_error = None
|
|
await db.commit()
|
|
await db.refresh(session)
|
|
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=None,
|
|
event_type="session_saved_as_story",
|
|
status="succeeded",
|
|
message="Voice session finalized into a story.",
|
|
metadata={"story_id": story.id},
|
|
)
|
|
|
|
return VoiceSessionFinalizeResponse(
|
|
session_id=session.id,
|
|
status=session.status,
|
|
story_id=story.id,
|
|
generation_job_id=None,
|
|
)
|
|
|
|
|
|
async def abandon_voice_session_service(
|
|
session_id: str,
|
|
request: VoiceSessionAbandonRequest,
|
|
user_id: str,
|
|
db: AsyncSession,
|
|
) -> VoiceSessionSummaryResponse:
|
|
session = await _get_owned_session(db, session_id=session_id, user_id=user_id)
|
|
if session.status in FINAL_SESSION_STATUSES:
|
|
raise HTTPException(status_code=409, detail="Voice session is already closed.")
|
|
|
|
session.status = "abandoned"
|
|
session.last_error = request.reason
|
|
await db.commit()
|
|
await db.refresh(session)
|
|
|
|
await _record_session_event(
|
|
db,
|
|
session_id=session.id,
|
|
turn_id=None,
|
|
event_type="session_abandoned",
|
|
status="succeeded",
|
|
message="Voice session abandoned by the user.",
|
|
metadata={"reason": request.reason},
|
|
)
|
|
await db.refresh(session)
|
|
return _session_to_summary(session)
|