Personas, Companionship & Creative Writing

# Define PersonaSpec; implement to_system_prompt
# Key operations: results display, RAG pipeline, prompt construction
from dataclasses import dataclass, field

@dataclass
class PersonaSpec:
 """Complete specification for a conversational persona."""

 # Core identity
 name: str
 role: str
 backstory: str

 # Personality
 traits: list[str]
 emotional_tone: str

 # Communication style
 vocabulary_level: str # "simple", "moderate", "technical", "academic"
 formality: str # "casual", "conversational", "professional", "formal"
 humor_style: str # "none", "dry", "playful", "sarcastic"
 typical_response_length: str # "brief", "moderate", "detailed"

 # Knowledge
 expertise_areas: list[str]
 knowledge_cutoff: str
 uncertainty_behavior: str # How the persona handles unknown topics

 # Guardrails
 forbidden_topics: list[str] = field(default_factory=list)
 never_behaviors: list[str] = field(default_factory=list)
 escalation_triggers: list[str] = field(default_factory=list)

 def to_system_prompt(self) -> str:
 """Convert persona spec into a system prompt."""
 return f"""You are {self.name}, {self.role}.

## Background
{self.backstory}

## Personality
Your core traits are: {', '.join(self.traits)}.
Your emotional tone is {self.emotional_tone}.

## Communication Style
- Vocabulary: {self.vocabulary_level}
- Formality: {self.formality}
- Humor: {self.humor_style}
- Response length: {self.typical_response_length}

## Expertise
You are knowledgeable about: {', '.join(self.expertise_areas)}.
When asked about topics outside your expertise: {self.uncertainty_behavior}

## Boundaries
Never discuss: {', '.join(self.forbidden_topics) if self.forbidden_topics else 'No restrictions'}
Never: {', '.join(self.never_behaviors) if self.never_behaviors else 'No restrictions'}
Escalate when: {', '.join(self.escalation_triggers) if self.escalation_triggers else 'Use your judgment'}
"""

# Example: A friendly cooking assistant persona
chef_persona = PersonaSpec(
 name="Chef Marco",
 role="a passionate Italian home cooking instructor",
 backstory=(
 "You grew up in a small kitchen in Bologna, learning to cook "
 "from your grandmother. You moved to New York 15 years ago and "
 "have been teaching home cooks ever since. You believe great "
 "food comes from simple ingredients treated with respect."
 ),
 traits=["warm", "encouraging", "opinionated about ingredients",
 "patient with beginners"],
 emotional_tone="enthusiastic and nurturing",
 vocabulary_level="moderate",
 formality="conversational",
 humor_style="playful",
 typical_response_length="moderate",
 expertise_areas=["Italian cuisine", "home cooking techniques",
 "ingredient selection", "kitchen equipment"],
 knowledge_cutoff="Classical and modern Italian cooking",
 uncertainty_behavior=(
 "Honestly say you are not sure and suggest the user consult "
 "a specialist for that cuisine or technique."
 ),
 forbidden_topics=["politics", "religion", "medical nutrition advice"],
 never_behaviors=[
 "Claim to be a licensed nutritionist or dietician",
 "Recommend raw consumption of potentially unsafe ingredients",
 "Disparage other cuisines or cooking traditions"
 ],
 escalation_triggers=[
 "User mentions food allergies (recommend consulting a doctor)",
 "User describes symptoms of foodborne illness"
 ]
)

print(chef_persona.to_system_prompt())

# Define CharacterConsistencyManager; implement __init__, build_consistency_context, update_relationship
# Key operations: prompt construction
class CharacterConsistencyManager:
 """Maintains character consistency across long conversations."""

 def __init__(self, persona: PersonaSpec):
 self.persona = persona
 self.character_facts: list[str] = [] # Established facts about the character
 self.relationship_state: dict = {
 "familiarity": 0.0, # 0 (stranger) to 1 (close friend)
 "trust_level": 0.5,
 "shared_experiences": [],
 "user_preferences": {},
 }

 def build_consistency_context(self) -> str:
 """Generate a consistency reminder to include in each prompt."""
 context_parts = []

 # Character facts established in conversation
 if self.character_facts:
 recent_facts = self.character_facts[-10:]
 context_parts.append(
 "## Previously Established Character Facts\n"
 "You have mentioned the following in past conversations. "
 "Remain consistent with these details:\n"
 + "\n".join(f"- {fact}" for fact in recent_facts)
 )

 # Relationship dynamics
 familiarity = self.relationship_state["familiarity"]
 if familiarity < 0.3:
 tone_guide = "You are still getting to know this person. Be friendly but maintain appropriate boundaries."
 elif familiarity < 0.7:
 tone_guide = "You have an established rapport. You can reference shared experiences and be more relaxed."
 else:
 tone_guide = "You know this person well. Your conversation style is warm and familiar."

 context_parts.append(f"## Relationship Context\n{tone_guide}")

 # Shared experiences
 shared = self.relationship_state["shared_experiences"]
 if shared:
 recent_shared = shared[-5:]
 context_parts.append(
 "## Shared Experiences\n"
 + "\n".join(f"- {exp}" for exp in recent_shared)
 )

 return "\n\n".join(context_parts)

 def extract_new_facts(self, assistant_message: str) -> None:
 """Extract and store any new character facts from the response."""
 # In production, use an LLM to extract facts
 # This is a simplified placeholder
 fact_indicators = [
 "I remember when", "I always", "I grew up",
 "My favorite", "I once", "Back when I"
 ]
 for indicator in fact_indicators:
 if indicator.lower() in assistant_message.lower():
 # Extract the sentence containing the fact
 for sentence in assistant_message.split("."):
 if indicator.lower() in sentence.lower():
 self.character_facts.append(sentence.strip())
 break

 def update_relationship(self, user_message: str,
 assistant_message: str) -> None:
 """Update relationship state based on the exchange."""
 # Gradually increase familiarity with each interaction
 self.relationship_state["familiarity"] = min(
 1.0,
 self.relationship_state["familiarity"] + 0.01
 )

# Define CoWritingAssistant; implement __init__, analyze_writing_style, continue_draft
# Key operations: visualization, RAG pipeline, prompt construction
from openai import OpenAI

client = OpenAI()

class CoWritingAssistant:
 """AI co-writing partner with style adaptation capabilities."""

 def __init__(self):
 self.writing_style: dict = {}
 self.story_context: dict = {
 "characters": [],
 "plot_points": [],
 "setting": "",
 "tone": "",
 "genre": ""
 }

 def analyze_writing_style(self, sample_text: str) -> dict:
 """Analyze a text sample to extract the author's style."""
 analysis_prompt = """Analyze the writing style of this text sample.
Return a JSON object with these fields:
- sentence_structure: "simple", "complex", "varied", "fragmented"
- vocabulary_level: "plain", "moderate", "literary", "experimental"
- tone: the overall emotional quality
- pacing: "fast", "moderate", "slow", "varied"
- perspective: "first_person", "second_person", "third_limited", "third_omniscient"
- distinctive_features: list of 3-5 specific stylistic habits
- dialogue_style: how characters speak
- description_density: "sparse", "moderate", "rich", "ornate"

Text sample:
\"\"\"
{text}
\"\"\"

Return valid JSON only."""

 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[{
 "role": "user",
 "content": analysis_prompt.format(text=sample_text)
 }],
 response_format={"type": "json_object"},
 temperature=0.3
 )
 import json
 self.writing_style = json.loads(
 response.choices[0].message.content
 )
 return self.writing_style

 def continue_draft(self, draft_so_far: str,
 instruction: str = "Continue naturally",
 words: int = 200) -> str:
 """Continue a draft in the established writing style."""
 style_desc = "\n".join(
 f"- {k}: {v}" for k, v in self.writing_style.items()
 )

 prompt = f"""You are a co-writing assistant. Continue the draft below,
matching the established writing style precisely.

## Writing Style to Match
{style_desc}

## Story Context
Genre: {self.story_context.get('genre', 'Not specified')}
Setting: {self.story_context.get('setting', 'Not specified')}
Tone: {self.story_context.get('tone', 'Not specified')}

## Instruction
{instruction}

## Draft So Far
{draft_so_far}

## Continue
Write approximately {words} words. Match the style exactly.
Do not add meta-commentary. Just continue the story."""

 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[{"role": "user", "content": prompt}],
 temperature=0.8,
 max_tokens=words * 2
 )
 return response.choices[0].message.content

 def suggest_alternatives(self, passage: str, count: int = 3) -> list:
 """Generate alternative phrasings for a passage."""
 prompt = f"""Rewrite this passage in {count} different ways,
maintaining the same meaning and approximate style but exploring
different word choices, sentence structures, or emphases.

Original:
\"\"\"{passage}\"\"\"

Return each alternative numbered 1-{count}."""

 response = client.chat.completions.create(
 model="gpt-4o",
 messages=[{"role": "user", "content": prompt}],
 temperature=0.9
 )
 return response.choices[0].message.content

# implement check_response_consistency
# Key operations: prompt construction, evaluation logic, API interaction
def check_response_consistency(
 persona: PersonaSpec,
 character_facts: list[str],
 proposed_response: str
) -> dict:
 """Check whether a proposed response is consistent with the persona."""

 check_prompt = f"""Evaluate whether this response is consistent with
the character specification. Flag any inconsistencies.

Character: {persona.name}
Traits: {', '.join(persona.traits)}
Vocabulary level: {persona.vocabulary_level}
Formality: {persona.formality}
Established facts:
{chr(10).join('- ' + f for f in character_facts[-10:])}

Proposed response:
\"\"\"{proposed_response}\"\"\"

Return JSON with:
- consistent: true/false
- issues: list of specific inconsistencies (empty if consistent)
- severity: "none", "minor", "major"
- suggestion: how to fix any issues (empty if consistent)"""

 response = client.chat.completions.create(
 model="gpt-4o-mini",
 messages=[{"role": "user", "content": check_prompt}],
 response_format={"type": "json_object"},
 temperature=0
 )

 import json
 return json.loads(response.choices[0].message.content)