# Estimate session cost based on modality configuration
def estimate_session_cost(
  duration_minutes: int = 30,
  turns_per_minute: float = 2.0,
  frames_in_context: int = 3,
  tokens_per_frame: int = 1000,
  system_tokens: int = 500,
  avg_history_tokens: int = 3000,
  input_cost_per_million: float = 2.50,   # GPT-4o input pricing
  output_cost_per_million: float = 10.00,  # GPT-4o output pricing
  avg_output_tokens: int = 150,
):
  total_turns = int(duration_minutes * turns_per_minute)
  visual_tokens = frames_in_context * tokens_per_frame
  input_per_turn = system_tokens + avg_history_tokens + visual_tokens
  total_input = input_per_turn * total_turns
  total_output = avg_output_tokens * total_turns

  input_cost = (total_input / 1_000_000) * input_cost_per_million
  output_cost = (total_output / 1_000_000) * output_cost_per_million

  return {
      "total_turns": total_turns,
      "total_input_tokens": total_input,
      "total_output_tokens": total_output,
      "input_cost_usd": round(input_cost, 4),
      "output_cost_usd": round(output_cost, 4),
      "total_cost_usd": round(input_cost + output_cost, 4),
      "visual_token_share": f"{(visual_tokens / input_per_turn) * 100:.0f}%",
  }

function estimateSessionCost({
durationMinutes = 30,
turnsPerMinute = 2.0,
framesInContext = 3,
tokensPerFrame = 1000,
systemTokens = 500,
avgHistoryTokens = 3000,
inputCostPerMillion = 2.50,
outputCostPerMillion = 10.00,
avgOutputTokens = 150,
} = {}) {
const totalTurns = Math.floor(durationMinutes * turnsPerMinute);
const visualTokens = framesInContext * tokensPerFrame;
const inputPerTurn = systemTokens + avgHistoryTokens + visualTokens;
const totalInput = inputPerTurn * totalTurns;
const totalOutput = avgOutputTokens * totalTurns;

const inputCost = (totalInput / 1_000_000) * inputCostPerMillion;
const outputCost = (totalOutput / 1_000_000) * outputCostPerMillion;

return {
  totalTurns,
  totalInputTokens: totalInput,
  totalOutputTokens: totalOutput,
  inputCostUsd: +inputCost.toFixed(4),
  outputCostUsd: +outputCost.toFixed(4),
  totalCostUsd: +(inputCost + outputCost).toFixed(4),
  visualTokenShare: `${((visualTokens / inputPerTurn) * 100).toFixed(0)}%`,
};
}

from livekit.agents import RoomInputOptions, VideoFrameOptions

room_input_options = RoomInputOptions(
  video_enabled=True,
  video_frame_options=VideoFrameOptions(
      capture_interval=3.0,
      max_frames_in_context=3,  # Only keep 3 most recent frames
      max_width=1024,
      max_height=768,
  ),
)

const roomInputOptions = {
videoEnabled: true,
videoFrameOptions: {
  captureInterval: 3.0,
  maxFramesInContext: 3,
  maxWidth: 1024,
  maxHeight: 768,
},
};

from livekit.agents import Agent

class SmartCaptureAgent(Agent):
  def __init__(self):
      super().__init__(
          instructions="""You are a study partner with camera access. You only analyze
          visual content when the user asks you to look at something. Do not describe
          what you see unprompted — wait for the user to ask.""",
      )

  async def on_user_turn_completed(self, turn_ctx):
      # Frames are only captured when the user speaks,
      # so silent periods produce zero image tokens
      await Agent.default.on_user_turn_completed(self, turn_ctx)

from livekit.agents import Agent, function_tool

class ContextEfficientAgent(Agent):
  def __init__(self):
      super().__init__(
          instructions="""You are a study partner. When you have analyzed a visual
          element (a page, diagram, or screen), create a concise text summary of
          what you saw. After summarizing, you no longer need the original image
          in context — your summary preserves the key information.""",
      )
      self._visual_summaries = []

  @function_tool
  async def summarize_visual(self, context, summary: str):
      """Store a text summary of something you just saw visually.
      Use this after analyzing an image to preserve the information
      without keeping the expensive image in context."""
      self._visual_summaries.append(summary)
      return f"Summary stored. You now have {len(self._visual_summaries)} visual summaries."

  @function_tool
  async def recall_summaries(self, context):
      """Retrieve all stored visual summaries from this session."""
      if not self._visual_summaries:
          return "No visual summaries stored yet."
      return "

".join(f"[{i+1}] {s}" for i, s in enumerate(self._visual_summaries))

import { Agent, functionTool } from "@livekit/agents";

class ContextEfficientAgent extends Agent {
private visualSummaries: string[] = [];

constructor() {
  super({
    instructions: `You are a study partner. When you have analyzed a visual
      element (a page, diagram, or screen), create a concise text summary of
      what you saw. After summarizing, you no longer need the original image
      in context — your summary preserves the key information.`,
  });
}

@functionTool({
  description: "Store a text summary of something you just saw visually.",
})
async summarizeVisual(context, { summary }) {
  this.visualSummaries.push(summary);
  return `Summary stored. You now have ${this.visualSummaries.length} visual summaries.`;
}

@functionTool({
  description: "Retrieve all stored visual summaries from this session.",
})
async recallSummaries(context) {
  if (this.visualSummaries.length === 0) return "No visual summaries stored yet.";
  return this.visualSummaries.map((s, i) => `[${i + 1}] ${s}`).join("

");
}
}