class HeliconeManualLogger:    def __init__(        self,        api_key: str,        headers: dict = {},        logging_endpoint: str = "https://api.worker.helicone.ai"    )

class LoggingOptions(TypedDict, total=False):    start_time: float    end_time: float    additional_headers: Dict[str, str]    time_to_first_token_ms: Optional[float]

def log_request(    self,    request: dict,    operation: Callable[[HeliconeResultRecorder], T],    additional_headers: dict = {},    provider: Optional[Union[Literal["openai", "anthropic"], str]] = None,) -> T

def send_log(    self,    provider: Optional[str],    request: dict,    response: Union[dict, str],    options: LoggingOptions)

class HeliconeResultRecorder:    def __init__(self, request: dict):        """Initialize with request data"""    def append_results(self, data: dict):        """Append results to be logged"""    def get_results(self) -> dict:        """Get all recorded results"""

import timefrom helicone_helpers import HeliconeManualLogger, LoggingOptions# Initialize the loggerhelicone = HeliconeManualLogger(api_key="your-helicone-api-key")# Log a request with a string responsestart_time = time.time()# Your request datarequest = {    "model": "custom-model",    "prompt": "Tell me a joke"}# Your response as a stringresponse = "Why did the chicken cross the road? To get to the other side!"# Log after some processing timeend_time = time.time()# Send the log with timing informationhelicone.send_log(    provider=None,  # Custom provider    request=request,    response=response,  # String response    options=LoggingOptions(        start_time=start_time,        end_time=end_time,        additional_headers={"Helicone-User-Id": "user-123"},        time_to_first_token_ms=150  # Optional time to first token in milliseconds    ))

from helicone_helpers import HeliconeManualLogger, LoggingOptionsimport openaiimport time# Initialize the loggerhelicone = HeliconeManualLogger(api_key="your-helicone-api-key")client = openai.OpenAI(api_key="your-openai-api-key")# Define your requestrequest = {    "model": "gpt-4o-mini",    "messages": [{"role": "user", "content": "Write a story about a robot."}],    "stream": True}def stream_operation(result_recorder):    start_time = time.time()    first_token_time = None    # Create a streaming response    response = client.chat.completions.create(**request)    # Process the stream and collect chunks    collected_chunks = []    for i, chunk in enumerate(response):        if i == 0 and first_token_time is None:            first_token_time = time.time()        collected_chunks.append(chunk)        # You can process each chunk here if needed    # Calculate time to first token in milliseconds    time_to_first_token = None    if first_token_time:        time_to_first_token = (first_token_time - start_time) * 1000  # convert to ms    # Record the results with timing information    result_recorder.append_results({        "chunks": [c.model_dump() for c in collected_chunks],        "time_to_first_token_ms": time_to_first_token    })    # Return the collected chunks or process them as needed    return collected_chunks# Log the streaming requestresult = helicone.log_request(    provider="openai",    request=request,    operation=stream_operation,    additional_headers={"Helicone-User-Id": "user-123"})

from helicone_helpers import HeliconeManualLoggerimport anthropic# Initialize the loggerhelicone = HeliconeManualLogger(api_key="your-helicone-api-key")client = anthropic.Anthropic(api_key="your-anthropic-api-key")# Define your requestrequest = {    "model": "claude-3-opus-20240229",    "messages": [{"role": "user", "content": "Explain quantum computing"}],    "max_tokens": 1000}def anthropic_operation(result_recorder):    # Create a response    response = client.messages.create(**request)    # Convert to dictionary for logging    response_dict = {        "id": response.id,        "content": [{"text": block.text, "type": block.type} for block in response.content],        "model": response.model,        "role": response.role,        "usage": {            "input_tokens": response.usage.input_tokens,            "output_tokens": response.usage.output_tokens        }    }    # Record the results    result_recorder.append_results(response_dict)    return response# Log the request with Anthropic provider specifiedresult = helicone.log_request(    provider="anthropic",    request=request,    operation=anthropic_operation)

from helicone_helpers import HeliconeManualLoggerimport requests# Initialize the loggerhelicone = HeliconeManualLogger(api_key="your-helicone-api-key")# Define your requestrequest = {    "model": "custom-model-name",    "prompt": "Generate a poem about nature",    "temperature": 0.7}def custom_model_operation(result_recorder):    # Make a request to your custom model API    response = requests.post(        "https://your-custom-model-api.com/generate",        json=request,        headers={"Authorization": "Bearer your-api-key"}    )    # Parse the response    response_data = response.json()    # Record the results    result_recorder.append_results(response_data)    return response_data# Log the request with no specific providerresult = helicone.log_request(    provider=None,  # No specific provider    request=request,    operation=custom_model_operation)

import timefrom helicone_helpers import HeliconeManualLogger, LoggingOptionsimport openai# Initialize the logger and clienthelicone_logger = HeliconeManualLogger(api_key="your-helicone-api-key")client = openai.OpenAI(api_key="your-openai-api-key")# Define your requestrequest_body = {    "model": "gpt-4o-mini",    "messages": [{"role": "user", "content": "Write a story about a robot"}],    "stream": True,    "stream_options": {        "include_usage": True    }}# Create the streaming responsestream = client.chat.completions.create(**request_body)# Track time to first tokenchunks = []time_to_first_token_ms = Nonestart_time = time.time()# Process the streamfor i, chunk in enumerate(stream):    # Record time to first token on first chunk    if i == 0 and not time_to_first_token_ms:        time_to_first_token_ms = (time.time() - start_time) * 1000    # Store chunks (you might want to process them differently)    chunks.append(chunk.model_dump_json())# Log the complete interaction with timing informationhelicone_logger.send_log(    provider="openai",    request=request_body,    response="\n".join(chunks),  # Join chunks or process as needed    options=LoggingOptions(        start_time=start_time,        end_time=time.time(),        additional_headers={"Helicone-User-Id": "user-123"},        time_to_first_token_ms=time_to_first_token_ms    ))