ReflectClient

def __init__(
    *,
    base_url: str = "https://api.starlight-search.com",
    api_key: str,
    project_id: str | None = None,
    timeout: float | httpx.Timeout = 60.0,
) -> None

from reflect_sdk import ReflectClient

client = ReflectClient(
    base_url="http://localhost:8000",
    api_key="rf_live_abc123_secret456",
    project_id="my-project",
)

@classmethod
def bootstrap(
    *,
    base_url: str,
    bootstrap_token: str,
    user_id: str,
    project_id: str,
    key_label: str = "Default Admin Key",
    environment: str = "live",
    timeout: float | httpx.Timeout = 60.0,
) -> BootstrapResponse

info = ReflectClient.bootstrap(
    base_url="http://localhost:8000",
    bootstrap_token="your-admin-token",
    user_id="user-1",
    project_id="new-project",
)
# info.api_key contains the plaintext key

def health(
) -> dict[str, str]

async def query_memories_async(
    *,
    task: str,
    limit: int = 10,
    lambda_: float = 0.5,
    metadata_filter: dict[str, Any] | None = None,
    similarity_threshold: float | None = None,
    mmr_lambda: float = 0.7,
) -> list[MemoryResponse]

async def augment_with_memories_async(
    *,
    task: str,
    limit: int = 10,
    lambda_: float = 0.5,
    metadata_filter: dict[str, Any] | None = None,
    similarity_threshold: float | None = None,
    mmr_lambda: float = 0.7,
) -> AugmentedTask

def query_memories(
    *,
    task: str,
    limit: int = 10,
    lambda_: float = 0.5,
    metadata_filter: dict[str, Any] | None = None,
    similarity_threshold: float | None = None,
    mmr_lambda: float = 0.7,
) -> list[MemoryResponse]

def get_skill(
) -> SkillResponse | None

async def get_skill_async(
) -> SkillResponse | None

def create_skill(
    *,
    n_passed: int | None = None,
    n_failed: int | None = None,
) -> SkillResponse

def augment_with_memories(
    *,
    task: str,
    limit: int = 10,
    lambda_: float = 0.5,
    metadata_filter: dict[str, Any] | None = None,
    similarity_threshold: float | None = None,
    mmr_lambda: float = 0.7,
) -> AugmentedTask

def trace(
    *,
    task: str,
    limit: int = 10,
    lambda_: float = 0.5,
    metadata_filter: dict[str, Any] | None = None,
    similarity_threshold: float | None = None,
    mmr_lambda: float = 0.7,
    blocking: bool = False,
    auto_fail_on_exception: bool = True,
    reference_context: str | None = None,
    alpha: float | None = None,
) -> Generator[TraceContext, None, None]

def trace_async(
    *,
    task: str,
    limit: int = 10,
    lambda_: float = 0.5,
    metadata_filter: dict[str, Any] | None = None,
    similarity_threshold: float | None = None,
    mmr_lambda: float = 0.7,
    blocking: bool = False,
    auto_fail_on_exception: bool = True,
    reference_context: str | None = None,
    alpha: float | None = None,
) -> AsyncGenerator[TraceContext, None]

def create_trace(
    *,
    task: str,
    trajectory: TrajectoryInput,
    final_response: str | None = None,
    retrieved_memory_ids: Sequence[str] = (),
    model: str | None = None,
    metadata: dict[str, Any] | None = None,
    review_result: str | None = None,
    feedback_text: str | None = None,
    reference_context: str | None = None,
    alpha: float | None = None,
) -> TraceCreateResponse

# After your agent responds to a user...
submission = client.create_trace(
    task="Summarize this article about climate change",
    trajectory=[
        {"role": "user", "content": "Summarize this article: ..."},
        {"role": "assistant", "content": "Here is a summary: ..."},
    ],
    model="gpt-5.4-mini",
    metadata={"user_id": "u123"},
)
# Returns immediately — your app continues serving requests.
# Review this trace later in the dashboard or via review_trace().

# Compare the agent's answer to the expected answer...
is_correct = agent_answer.strip() == expected_answer.strip()

submission = client.create_trace(
    task=problem_description,
    trajectory=messages,
    retrieved_memory_ids=[m.id for m in memories],
    model="gpt-5.4-mini",
    review_result="pass" if is_correct else "fail",
    feedback_text=None if is_correct else f"Expected {expected_answer}",
)
# Reflect generates a reflection in the background.
# Next time your agent sees a similar task, it can retrieve
# this memory to avoid repeating the same mistake.

async def create_trace_async(
    *,
    task: str,
    trajectory: TrajectoryInput,
    final_response: str | None = None,
    retrieved_memory_ids: Sequence[str] = (),
    model: str | None = None,
    metadata: dict[str, Any] | None = None,
    review_result: str | None = None,
    feedback_text: str | None = None,
    reference_context: str | None = None,
    alpha: float | None = None,
) -> TraceCreateResponse

def wait_for_trace(
    *,
    trace_id: str,
    require_reviewed: bool = False,
    poll_interval: float = 0.25,
    wait_timeout: float = 60.0,
) -> TraceResponse

async def wait_for_trace_async(
    *,
    trace_id: str,
    require_reviewed: bool = False,
    poll_interval: float = 0.25,
    wait_timeout: float = 60.0,
) -> TraceResponse

def create_trace_and_wait(
    *,
    task: str,
    trajectory: TrajectoryInput,
    final_response: str | None = None,
    retrieved_memory_ids: Sequence[str] = (),
    model: str | None = None,
    metadata: dict[str, Any] | None = None,
    review_result: str | None = None,
    feedback_text: str | None = None,
    reference_context: str | None = None,
    alpha: float | None = None,
    poll_interval: float = 0.25,
    wait_timeout: float = 60.0,
) -> TraceResponse

for problem in problems:
    # Retrieve memories from previous tasks in this run
    augmented = client.augment_with_memories(problem.question)
    answer = my_agent.solve(augmented.augmented_task)
    is_correct = answer.strip() == problem.expected.strip()

    trace = client.create_trace_and_wait(
        task=problem.question,
        trajectory=augmented_messages,
        final_response=answer,
        retrieved_memory_ids=[m.id for m in augmented.memories],
        model="gpt-5.4-mini",
        review_result="pass" if is_correct else "fail",
        feedback_text=None if is_correct else f"Expected {problem.expected}",
    )
    # MemoryResponse is now stored — the next iteration can retrieve it.

answer = my_agent.solve(task)
result = input("Was this correct? [y/n]: ")

trace = client.create_trace_and_wait(
    task=task,
    trajectory=messages,
    final_response=answer,
    retrieved_memory_ids=[m.id for m in memories],
    review_result="pass" if result == "y" else "fail",
    feedback_text=input("Feedback: ") if result != "y" else None,
)
print(f"MemoryResponse created: {trace.created_memory_id}")

async def create_trace_and_wait_async(
    *,
    task: str,
    trajectory: TrajectoryInput,
    final_response: str | None = None,
    retrieved_memory_ids: Sequence[str] = (),
    model: str | None = None,
    metadata: dict[str, Any] | None = None,
    review_result: str | None = None,
    feedback_text: str | None = None,
    reference_context: str | None = None,
    alpha: float | None = None,
    poll_interval: float = 0.25,
    wait_timeout: float = 60.0,
) -> TraceResponse

def list_traces(
    *,
    review_status: str | None = None,
) -> list[TraceResponse]

def get_trace(
    trace_id: str,
) -> TraceResponse

async def get_trace_async(
    trace_id: str,
) -> TraceResponse

def review_trace(
    *,
    trace_id: str,
    result: str,
    feedback_text: str | None = None,
    alpha: float | None = None,
) -> TraceResponse

def delete_traces(
    trace_ids: Sequence[str],
) -> DeleteTracesResponse

def list_api_keys(
) -> list[ApiKeyResponse]

def create_api_key(
    *,
    label: str,
    scopes: Sequence[str],
    environment: str = "live",
) -> ApiKeyCreateResponse

def revoke_api_key(
    key_id: str,
) -> ApiKeyResponse

def delete_project(
) -> DeleteProjectResponse