SYMBOL INDEX (741 symbols across 95 files)

FILE: agentkit/trace/builder.py
  class SpanBuilder (line 22) | class SpanBuilder:
    method __init__ (line 36) | def __init__(self, trace_id: Optional[str] = None, app_name: Optional[...
    method with_id (line 47) | def with_id(self, span_id: str) -> "SpanBuilder":
    method with_name (line 52) | def with_name(self, name: str) -> "SpanBuilder":
    method with_trace_id (line 57) | def with_trace_id(self, trace_id: str) -> "SpanBuilder":
    method with_start_time (line 62) | def with_start_time(self, start_time: datetime) -> "SpanBuilder":
    method with_end_time (line 67) | def with_end_time(self, end_time: datetime) -> "SpanBuilder":
    method with_tag (line 72) | def with_tag(self, key: str, value: str) -> "SpanBuilder":
    method with_tags (line 77) | def with_tags(self, tags: dict[str, str]) -> "SpanBuilder":
    method with_payload (line 82) | def with_payload(self, payload: Any) -> "SpanBuilder":
    method with_parent (line 87) | def with_parent(self, parent: Span) -> "SpanBuilder":
    method with_parent_id (line 95) | def with_parent_id(self, parent_id: str) -> "SpanBuilder":
    method with_app_name (line 100) | def with_app_name(self, app_name: str) -> "SpanBuilder":
    method build (line 105) | def build(self) -> Span:
  class FunctionSpanBuilder (line 121) | class FunctionSpanBuilder(SpanBuilder):
    method __init__ (line 134) | def __init__(self, trace_id: Optional[str] = None, app_name: Optional[...
    method with_function_name (line 141) | def with_function_name(self, name: str) -> "FunctionSpanBuilder":
    method with_arguments (line 148) | def with_arguments(self, arguments: dict[str, Any]) -> "FunctionSpanBu...
    method with_return_value (line 153) | def with_return_value(self, ret: Any) -> "FunctionSpanBuilder":
    method with_error (line 158) | def with_error(self, code: int, message: str) -> "FunctionSpanBuilder":
    method build (line 163) | def build(self) -> Span:
  class HTTPSpanBuilder (line 176) | class HTTPSpanBuilder(SpanBuilder):
    method __init__ (line 189) | def __init__(self, trace_id: Optional[str] = None, app_name: Optional[...
    method with_url (line 198) | def with_url(self, url: str) -> "HTTPSpanBuilder":
    method with_method (line 205) | def with_method(self, method: str) -> "HTTPSpanBuilder":
    method with_header (line 212) | def with_header(self, key: str, value: str | list[str]) -> "HTTPSpanBu...
    method with_headers (line 219) | def with_headers(self, headers: dict[str, list[str]]) -> "HTTPSpanBuil...
    method with_body (line 224) | def with_body(self, body: str | bytes) -> "HTTPSpanBuilder":
    method with_response (line 229) | def with_response(self, response: str | bytes) -> "HTTPSpanBuilder":
    method with_error (line 234) | def with_error(self, code: int, message: str) -> "HTTPSpanBuilder":
    method build (line 239) | def build(self) -> Span:
  class EventBuilder (line 254) | class EventBuilder:
    method __init__ (line 266) | def __init__(self, trace_id: Optional[str] = None, app_name: Optional[...
    method with_id (line 276) | def with_id(self, event_id: str) -> "EventBuilder":
    method with_name (line 281) | def with_name(self, name: str) -> "EventBuilder":
    method with_trace_id (line 286) | def with_trace_id(self, trace_id: str) -> "EventBuilder":
    method with_timestamp (line 291) | def with_timestamp(self, timestamp: datetime) -> "EventBuilder":
    method with_tag (line 296) | def with_tag(self, key: str, value: str) -> "EventBuilder":
    method with_tags (line 301) | def with_tags(self, tags: dict[str, str]) -> "EventBuilder":
    method with_data (line 306) | def with_data(self, data: Any) -> "EventBuilder":
    method with_parent (line 311) | def with_parent(self, parent: Span) -> "EventBuilder":
    method with_parent_id (line 319) | def with_parent_id(self, parent_id: str) -> "EventBuilder":
    method build (line 324) | def build(self) -> Event:

FILE: agentkit/trace/context.py
  class HTTPMethod (line 14) | class HTTPMethod(str, Enum):
  class SpanContext (line 50) | class SpanContext:
    method __init__ (line 57) | def __init__(
    method get_current_span (line 75) | def get_current_span(self) -> Optional[Span]:
    method get_current_trace_id (line 79) | def get_current_trace_id(self) -> str:
    method set_trace_id (line 85) | def set_trace_id(self, trace_id: str):
    method merge_tags (line 89) | def merge_tags(self, tags: dict[str, str]) -> dict[str, str]:
    method span (line 97) | def span(
    method record_event (line 155) | def record_event(
    method function_span (line 187) | def function_span(
    method llm_span (line 217) | def llm_span(
    method tool_span (line 245) | def tool_span(
    method http_span (line 270) | def http_span(
  function get_current_context (line 315) | def get_current_context() -> SpanContext:
  function set_default_tracer (line 324) | def set_default_tracer(tracer: Tracer):
  function set_default_app_name (line 329) | def set_default_app_name(app_name: str):
  function get_default_tracer (line 334) | def get_default_tracer() -> Tracer:
  function get_default_app_name (line 339) | def get_default_app_name() -> str:
  function trace_function (line 345) | def trace_function(
  function start_trace (line 405) | def start_trace(trace_id: Optional[str] = None, context: Optional[SpanCo...
  function record_event (line 420) | def record_event(
  function create_span (line 437) | def create_span(

FILE: agentkit/trace/default.py
  class DefaultSettings (line 8) | class DefaultSettings:
  function set_default (line 16) | def set_default(**kwargs):
  function get_default_settings (line 24) | def get_default_settings() -> DefaultSettings:
  function get_default (line 28) | def get_default(key: str):

FILE: agentkit/trace/local_tracer.py
  class LocalStorageTracer (line 10) | class LocalStorageTracer(Tracer):
    method __init__ (line 11) | def __init__(self, storage_dir: str = "./traces"):
    method _get_trace_spans_file (line 19) | def _get_trace_spans_file(self, trace_id: str) -> Path:
    method _get_trace_events_file (line 22) | def _get_trace_events_file(self, trace_id: str) -> Path:
    method record_span (line 25) | def record_span(self, span: Span) -> None:
    method record_event (line 31) | def record_event(self, event: Event) -> None:
    method get_spans (line 37) | def get_spans(self, trace_id: str) -> list[Span]:
    method get_events (line 57) | def get_events(self, trace_id: str) -> list[Event]:
    method get_trace (line 77) | def get_trace(self, trace_id: str) -> Optional[dict]:
    method get_trace_raw (line 92) | def get_trace_raw(self, trace_id: str) -> Optional[dict]:
    method list_traces (line 140) | def list_traces(self, limit: int = 100, offset: int = 0) -> list[dict]:

FILE: agentkit/trace/remote_tracer.py
  class RemoteEvent (line 14) | class RemoteEvent(BaseModel):
  class RemoteTracer (line 22) | class RemoteTracer(Tracer):
    method __init__ (line 29) | def __init__(
    method __del__ (line 52) | def __del__(self):
    method _send_to_api (line 59) | def _send_to_api(self, data: str) -> bool:
    method record_span (line 97) | def record_span(self, span: Span) -> None:
    method record_event (line 112) | def record_event(self, event: Event) -> None:
    method get_spans (line 127) | def get_spans(self, trace_id: str) -> list[Span]:
    method get_events (line 136) | def get_events(self, trace_id: str) -> list[Event]:
    method get_trace (line 145) | def get_trace(self, trace_id: str) -> Optional[dict]:
    method list_traces (line 154) | def list_traces(self, limit: int = 100, offset: int = 0) -> list[dict]:
  class HybridTracer (line 164) | class HybridTracer(Tracer):
    method __init__ (line 177) | def __init__(self, local_tracer: Tracer, remote_tracer: RemoteTracer):
    method record_span (line 188) | def record_span(self, span: Span) -> None:
    method record_event (line 193) | def record_event(self, event: Event) -> None:
    method get_spans (line 198) | def get_spans(self, trace_id: str) -> list[Span]:
    method get_events (line 202) | def get_events(self, trace_id: str) -> list[Event]:
    method get_trace (line 206) | def get_trace(self, trace_id: str) -> Optional[dict]:
    method get_trace_raw (line 210) | def get_trace_raw(self, trace_id: str) -> Optional[dict]:
    method list_traces (line 214) | def list_traces(self, limit: int = 100, offset: int = 0) -> list[dict]:

FILE: agentkit/trace/span.py
  class HTTPMethod (line 6) | class HTTPMethod(str, Enum):
  class DataType (line 24) | class DataType(str, Enum):
  class SpanType (line 29) | class SpanType(str, Enum):
  class LLMSpanPayload (line 37) | class LLMSpanPayload(BaseModel):
  class ToolSpanPayload (line 44) | class ToolSpanPayload(BaseModel):
  class FunctionSpanPayload (line 51) | class FunctionSpanPayload(BaseModel):
  class HTTPSpanPayload (line 59) | class HTTPSpanPayload(BaseModel):
  class OtherSpanPayload (line 79) | class OtherSpanPayload(BaseModel):
  class Span (line 84) | class Span(BaseModel):
    method update_payload (line 104) | def update_payload(
    method update_payload_data (line 119) | def update_payload_data(self, **kwargs) -> "Span":
    method add_tag (line 131) | def add_tag(self, key: str, value: str) -> "Span":
    method add_tags (line 136) | def add_tags(self, tags: dict[str, str]) -> "Span":
  class EventType (line 142) | class EventType(str, Enum):
  class DeltaEventPayload (line 147) | class DeltaEventPayload(BaseModel):
  class OtherEventPayload (line 152) | class OtherEventPayload(BaseModel):
  class Event (line 157) | class Event(BaseModel):

FILE: agentkit/trace/tracer.py
  class Tracer (line 7) | class Tracer(ABC):
    method record_span (line 9) | def record_span(self, span: Span) -> None:
    method record_event (line 13) | def record_event(self, event: Event) -> None:
    method get_spans (line 17) | def get_spans(self, trace_id: str) -> list[Span]:
    method get_events (line 21) | def get_events(self, trace_id: str) -> list[Event]:
    method get_trace (line 25) | def get_trace(self, trace_id: str) -> Optional[dict]:
    method list_traces (line 29) | def list_traces(self, limit: int = 100, offset: int = 0) -> list[dict]:
    method get_trace_raw (line 32) | def get_trace_raw(self, trace_id: str) -> Optional[dict]:

FILE: agentkit/trace/types.py
  class Error (line 4) | class Error(BaseModel):

FILE: cortex-ui/src/components/EndpointConfig.tsx
  type EndpointConfigProps (line 8) | interface EndpointConfigProps {

FILE: cortex-ui/src/components/ErrorBoundary.tsx
  type Props (line 4) | interface Props {
  type State (line 8) | interface State {
  class ErrorBoundary (line 13) | class ErrorBoundary extends Component<Props, State> {
    method constructor (line 14) | constructor(props: Props) {
    method getDerivedStateFromError (line 19) | static getDerivedStateFromError(error: Error): State {
    method componentDidCatch (line 23) | componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
    method render (line 27) | render() {

FILE: cortex-ui/src/components/FilePanel.tsx
  type FileResult (line 25) | interface FileResult {
  type FilePanelProps (line 37) | interface FilePanelProps {

FILE: cortex-ui/src/components/FinalAnswer.tsx
  type FinalAnswerProps (line 20) | interface FinalAnswerProps {
  function extractAnswerContent (line 28) | function extractAnswerContent(content: string): string {
  function preprocessCitations (line 41) | function preprocessCitations(content: string, citations: CitationStore):...

FILE: cortex-ui/src/components/SearchResultsPanel.tsx
  type SearchResultsPanelProps (line 19) | interface SearchResultsPanelProps {

FILE: cortex-ui/src/components/ShellPanel.tsx
  type ShellResult (line 20) | interface ShellResult {
  type ShellPanelProps (line 27) | interface ShellPanelProps {

FILE: cortex-ui/src/components/TodoPanel.tsx
  type TaskStatus (line 20) | type TaskStatus = 'completed' | 'in_progress' | 'pending' | 'not_started';
  type TodoItem (line 23) | interface TodoItem {
  type TodoPanelProps (line 35) | interface TodoPanelProps {
  function parseTodoResult (line 47) | function parseTodoResult(content: string): TodoItem[] {
  function isTodoResult (line 122) | function isTodoResult(content: string): boolean {
  function getStatusConfig (line 133) | function getStatusConfig(status: TaskStatus) {
  function getPriorityTag (line 149) | function getPriorityTag(priority?: 'high' | 'medium' | 'low') {
  function formatTime (line 162) | function formatTime(timeStr?: string) {

FILE: cortex-ui/src/components/WebPagePanel.tsx
  type WebPageResult (line 26) | interface WebPageResult {
  type WebPagePanelProps (line 37) | interface WebPagePanelProps {
  function parseBatchOpenResult (line 319) | function parseBatchOpenResult(resultStr: string): WebPageResult[] {
  function isBatchOpenResult (line 377) | function isBatchOpenResult(resultStr: string): boolean {

FILE: cortex-ui/src/pages/ChatPage.tsx
  type ToolCall (line 50) | interface ToolCall {
  type ToolCallStatus (line 59) | interface ToolCallStatus {
  type MessageItem (line 65) | interface MessageItem {
  type ContentItem (line 93) | interface ContentItem {

FILE: cortex-ui/src/services/api.ts
  constant DEFAULT_API_BASE_URL (line 4) | const DEFAULT_API_BASE_URL = 'http://localhost:8001';
  constant API_BASE_URL (line 13) | const API_BASE_URL =
  class WebSocketService (line 36) | class WebSocketService {
    method connect (line 42) | connect(url: string): Promise<void> {
    method send (line 83) | send(data: AgentEvent): void {
    method onMessage (line 91) | onMessage(handler: (event: AgentEvent) => void): void {
    method onError (line 95) | onError(handler: (error: Event) => void): void {
    method onClose (line 99) | onClose(handler: () => void): void {
    method close (line 103) | close(): void {
    method isConnected (line 119) | isConnected(): boolean {

FILE: cortex-ui/src/types/citation.ts
  type SearchResultItem (line 6) | interface SearchResultItem {
  type QueryResult (line 17) | interface QueryResult {
  type BatchSearchResults (line 24) | interface BatchSearchResults {
  type CitationInfo (line 31) | interface CitationInfo {
  type CitationStore (line 39) | type CitationStore = Map<string, CitationInfo>;

FILE: cortex-ui/src/types/index.ts
  type ModelParams (line 3) | interface ModelParams {
  type ComponentConfig (line 10) | interface ComponentConfig {
  type AgentConfig (line 15) | interface AgentConfig {
  type ChatMessage (line 30) | interface ChatMessage {
  type AgentEventType (line 39) | enum AgentEventType {
  type AgentMessageType (line 48) | enum AgentMessageType {
  type AgentRunningStatus (line 54) | enum AgentRunningStatus {
  type AgentResponse (line 61) | interface AgentResponse {
  type AgentRequest (line 69) | interface AgentRequest {
  type ClientToolCall (line 75) | interface ClientToolCall {
  type AgentEvent (line 83) | interface AgentEvent {

FILE: cortex-ui/src/utils/citationParser.ts
  function parseSearchResultsXML (line 11) | function parseSearchResultsXML(xmlContent: string): CitationStore {
  function extractXMLValue (line 44) | function extractXMLValue(content: string, tagName: string): string | und...
  function isBatchSearchResult (line 53) | function isBatchSearchResult(content: string): boolean {
  function extractCitationsFromToolResult (line 61) | function extractCitationsFromToolResult(result: string): CitationStore {
  function parseQueryResults (line 71) | function parseQueryResults(xmlContent: string): QueryResult[] {

FILE: cortex-ui/src/vite-env.d.ts
  type ImportMetaEnv (line 3) | interface ImportMetaEnv {
  type ImportMeta (line 7) | interface ImportMeta {

FILE: cortex/agents/agent_factory.py
  class AgentFactory (line 11) | class AgentFactory:
    method list_agents (line 19) | def list_agents(self) -> list[AgentConfig]:
    method get_default_agent_config (line 25) | def get_default_agent_config(self, name: str) -> AgentConfig:
    method register_agent (line 36) | def register_agent(
    method make_agent (line 49) | async def make_agent(

FILE: cortex/agents/base_agent.py
  class BaseAgent (line 21) | class BaseAgent:
    method update_from_config (line 32) | def update_from_config(self):
    method __init__ (line 44) | def __init__(
    method __aenter__ (line 59) | async def __aenter__(self):
    method __aexit__ (line 62) | async def __aexit__(self, exc_type, exc_value, traceback):
    method run (line 65) | async def run(
    method _run (line 77) | async def _run(
    method model_api (line 94) | def model_api(self) -> ModelAPI:
    method toolset (line 97) | def toolset(self) -> ToolSet | None:
    method as_tool (line 106) | def as_tool(self, timeout: float | None = None) -> dict[str, Any]:
    method has_tool_call (line 159) | def has_tool_call(message: ChatMessage) -> bool:
    method _execute_single_tool (line 178) | async def _execute_single_tool(self, tool_call: ChatToolCall) -> ChatM...
    method run_tool_call (line 224) | async def run_tool_call(self, message: ChatMessage) -> list[ChatMessage]:
    method run_tool_call_concurrency (line 260) | async def run_tool_call_concurrency(

FILE: cortex/agents/base_step_agent.py
  function _get_encoding (line 45) | def _get_encoding(model_name: str | None):
  function _estimate_token_length (line 62) | def _estimate_token_length(messages: list[ChatMessage], model_name: str ...
  function _compress_batch_search_result (line 85) | def _compress_batch_search_result(content: str) -> str:
  class BaseStepAgent (line 97) | class BaseStepAgent(BaseAgent):
    method __init__ (line 105) | def __init__(
    method _insert_final_prompt (line 163) | def _insert_final_prompt(self) -> None:
    method _make_force_final_answer_message (line 173) | def _make_force_final_answer_message(self) -> ChatMessage:
    method _ensure_final_prompt (line 177) | def _ensure_final_prompt(self, messages: list[ChatMessage]) -> None:
    method _copy_messages (line 195) | def _copy_messages(messages: list[ChatMessage]) -> list[ChatMessage]:
    method _compress_batch_search_in_block (line 206) | def _compress_batch_search_in_block(cls, block: dict) -> bool:
    method _compress_batch_search_in_content (line 226) | def _compress_batch_search_in_content(cls, content: Any) -> tuple[Any,...
    method _prepare_messages_for_model (line 243) | def _prepare_messages_for_model(self) -> list[ChatMessage]:
    method _shrink_batch_search_results (line 266) | def _shrink_batch_search_results(self, messages: list[ChatMessage]) ->...
    method _parse_tool_call_arguments (line 278) | def _parse_tool_call_arguments(raw_arguments: Any) -> dict[str, Any]:
    method _is_search_tool_call (line 288) | def _is_search_tool_call(self, tool_name: str | None, tool_args: dict[...
    method _drop_oldest_tool_cycle (line 301) | def _drop_oldest_tool_cycle(
    method _trim_oldest_messages (line 357) | def _trim_oldest_messages(self, messages: list[ChatMessage]) -> bool:
    method _ensure_context_within_upper_limit (line 377) | def _ensure_context_within_upper_limit(self, messages: list[ChatMessag...
    method _handle_context_overflow (line 399) | def _handle_context_overflow(self, messages: list[ChatMessage]) -> None:
    method _run (line 450) | async def _run(
    method _step (line 599) | async def _step(

FILE: cortex/agents/checkpoint_agent/checkpoint_agent.py
  class PendingToolCall (line 22) | class PendingToolCall(BaseModel):
  class CheckpointState (line 29) | class CheckpointState(BaseModel):
  class CheckpointAgent (line 42) | class CheckpointAgent(BaseAgent):
    method __init__ (line 45) | def __init__(
    method _init_state (line 58) | def _init_state(
    method _process_tool_call_results (line 73) | async def _process_tool_call_results(
    method _execute_step (line 93) | async def _execute_step(
    method _update_client_tool_results (line 165) | async def _update_client_tool_results(self, state: CheckpointState) ->...
    method _should_continue (line 215) | def _should_continue(self, state: CheckpointState) -> bool:
    method _run (line 230) | async def _run(
    method _step (line 275) | async def _step(
    method _tool_call_handler (line 296) | async def _tool_call_handler(

FILE: cortex/agents/checkpoint_agent/checkpointer.py
  class CheckpointStorage (line 18) | class CheckpointStorage:
    method save_state (line 19) | def save_state(self, checkpoint_id: str, state: dict[str, Any]):
    method load_state (line 23) | def load_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method delete_state (line 27) | def delete_state(self, checkpoint_id: str):
    method asave_state (line 31) | async def asave_state(self, checkpoint_id: str, state: dict[str, Any]):
    method aload_state (line 35) | async def aload_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method adelete_state (line 39) | async def adelete_state(self, checkpoint_id: str):
  class CheckPointer (line 44) | class CheckPointer(Generic[T]):
    method __init__ (line 47) | def __init__(
    method __enter__ (line 69) | def __enter__(self) -> T:
    method __exit__ (line 78) | def __exit__(self, exc_type, exc_value, traceback):
    method __aenter__ (line 91) | async def __aenter__(self):
    method __aexit__ (line 94) | async def __aexit__(self, exc_type, exc_value, traceback):
  class MemoryCheckPointer (line 98) | class MemoryCheckPointer(CheckpointStorage):
    method __init__ (line 101) | def __init__(self):
    method save_state (line 104) | def save_state(self, checkpoint_id: str, state: dict[str, Any]):
    method load_state (line 109) | def load_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method delete_state (line 116) | def delete_state(self, checkpoint_id: str):
    method asave_state (line 122) | async def asave_state(self, checkpoint_id: str, state: dict[str, Any]):
    method aload_state (line 126) | async def aload_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method adelete_state (line 130) | async def adelete_state(self, checkpoint_id: str):
  class FileCheckPointer (line 135) | class FileCheckPointer(CheckpointStorage):
    method __init__ (line 138) | def __init__(self, checkpoint_dir: str):
    method _get_checkpoint_file (line 150) | def _get_checkpoint_file(self, checkpoint_id: str) -> Path:
    method save_state (line 154) | def save_state(self, checkpoint_id: str, state: dict[str, Any]):
    method load_state (line 168) | def load_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method delete_state (line 186) | def delete_state(self, checkpoint_id: str):
    method asave_state (line 193) | async def asave_state(self, checkpoint_id: str, state: dict[str, Any]):
    method aload_state (line 197) | async def aload_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method adelete_state (line 201) | async def adelete_state(self, checkpoint_id: str):
  class SqliteCheckPointer (line 206) | class SqliteCheckPointer(CheckpointStorage):
    method __init__ (line 209) | def __init__(self, db_path: str):
    method _init_db (line 228) | def _init_db(self):
    method __enter__ (line 248) | def __enter__(self):
    method __exit__ (line 254) | def __exit__(self, exc_type, exc_value, traceback):
    method __aenter__ (line 260) | async def __aenter__(self):
    method __aexit__ (line 263) | async def __aexit__(self, exc_type, exc_value, traceback):
    method save_state (line 266) | def save_state(self, checkpoint_id: str, state: dict[str, Any]):
    method load_state (line 294) | def load_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method delete_state (line 323) | def delete_state(self, checkpoint_id: str):
    method asave_state (line 338) | async def asave_state(self, checkpoint_id: str, state: dict[str, Any]):
    method aload_state (line 342) | async def aload_state(self, checkpoint_id: str) -> dict[str, Any] | None:
    method adelete_state (line 346) | async def adelete_state(self, checkpoint_id: str):

FILE: cortex/agents/checkpoint_agent/react_agent.py
  class CheckpointReActAgent (line 24) | class CheckpointReActAgent(CheckpointAgent):
    method __init__ (line 34) | def __init__(
    method _step (line 59) | async def _step(
    method _tool_call_handler (line 95) | async def _tool_call_handler(

FILE: cortex/agents/input/input.py
  class InputChannel (line 12) | class InputChannel(Generic[T]):
    method __init__ (line 15) | def __init__(self, queue: asyncio.Queue[T]) -> None:
    method get (line 18) | async def get(self) -> list[T]:
    method get_no_wait (line 34) | async def get_no_wait(self) -> list[T]:

FILE: cortex/agents/react_agent.py
  function _check_if_finished (line 24) | def _check_if_finished(response_message: ChatMessage | None) -> bool:
  function process_messages (line 36) | async def process_messages(
  class ReActAgent (line 150) | class ReActAgent(BaseStepAgent):
    method __init__ (line 160) | def __init__(
    method _step (line 180) | async def _step(

FILE: cortex/agents/types.py
  class RunnerType (line 10) | class RunnerType(str, Enum):
  class AgentRunningStatus (line 17) | class AgentRunningStatus(str, Enum):
  class AgentMessageType (line 26) | class AgentMessageType(str, Enum):
  class AgentResponseType (line 34) | class AgentResponseType(str, Enum):
  class AgentConfig (line 42) | class AgentConfig(BaseModel):
  class AgentResponse (line 59) | class AgentResponse(BaseModel):
    method get_type (line 71) | def get_type(self) -> AgentResponseType:
    method __add__ (line 81) | def __add__(self, other: "AgentResponse") -> "AgentResponse":

FILE: cortex/context/__init__.py
  function make_simple_context (line 10) | def make_simple_context(session_id: str) -> BaseContext:
  function make_file_context (line 14) | def make_file_context(path: str, session_id: str) -> BaseContext:

FILE: cortex/context/base_context.py
  class BaseContext (line 9) | class BaseContext(ABC):
    method __init__ (line 12) | def __init__(self, session_id: str):
    method add (line 22) | def add(self, messages: list[ChatMessage]) -> None:
    method get_all (line 32) | def get_all(self) -> List[ChatMessage]:

FILE: cortex/context/file_context.py
  class FileContext (line 14) | class FileContext(BaseContext):
    method __init__ (line 17) | def __init__(
    method __del__ (line 44) | def __del__(self):
    method _load_messages (line 52) | def _load_messages(self) -> None:
    method _save_messages (line 67) | def _save_messages(self) -> None:
    method _delayed_write (line 80) | async def _delayed_write(self) -> None:
    method _schedule_write (line 87) | def _schedule_write(self) -> None:
    method add (line 100) | def add(self, messages: list[ChatMessage]) -> None:
    method get_all (line 109) | def get_all(self) -> List[ChatMessage]:
    method clear (line 117) | def clear(self) -> None:
    method flush (line 127) | def flush(self) -> None:

FILE: cortex/context/simple_context.py
  class SimpleContext (line 10) | class SimpleContext(BaseContext):
    method __init__ (line 13) | def __init__(self, session_id: str):
    method add (line 16) | def add(self, msg: list[ChatMessage]) -> None:
    method get_all (line 23) | def get_all(self) -> List[ChatMessage]:

FILE: cortex/env.py
  function _repo_root (line 7) | def _repo_root() -> Path:
  function _parse_env_line (line 11) | def _parse_env_line(line: str) -> tuple[str, str] | None:
  function _load_env_fallback (line 29) | def _load_env_fallback(path: Path) -> None:
  function load_env (line 42) | def load_env() -> None:

FILE: cortex/examples/agents/ask_input_agent.py
  function init_ask_input_tools (line 28) | async def init_ask_input_tools() -> ToolSet:
  class AskInputAgent (line 59) | class AskInputAgent(BaseAgent):
    method __init__ (line 67) | def __init__(
    method _run (line 73) | async def _run(
  function make_ask_input_agent (line 192) | async def make_ask_input_agent(
  function get_ask_input_agent_config (line 203) | def get_ask_input_agent_config() -> AgentConfig:

FILE: cortex/examples/agents/deep_reasearch_agent.py
  function init_deep_research_tools (line 11) | async def init_deep_research_tools() -> ToolSet:
  function get_deep_research_agent_config (line 32) | def get_deep_research_agent_config() -> AgentConfig:
  function make_deep_research_agent (line 75) | async def make_deep_research_agent(session_id: str, config: AgentConfig)...

FILE: cortex/examples/agents/main_agent.py
  function init_main_tools (line 22) | async def init_main_tools() -> ToolSet:
  function make_main_agent (line 53) | async def make_main_agent(
  function get_main_agent_config (line 64) | def get_main_agent_config() -> AgentConfig:

FILE: cortex/examples/agents/math_agent.py
  function add (line 19) | def add(a: float, b: float) -> float:
  function subtract (line 32) | def subtract(a: float, b: float) -> float:
  function multiply (line 45) | def multiply(a: float, b: float) -> float:
  function divide (line 58) | def divide(a: float, b: float) -> float:
  function power (line 76) | def power(base: float, exponent: float) -> float:
  function sqrt (line 89) | def sqrt(number: float) -> float:
  function calculate_expression (line 106) | def calculate_expression(expression: str) -> float:
  function init_math_tools (line 128) | async def init_math_tools() -> ToolSet:
  function make_math_agent (line 159) | async def make_math_agent(
  function get_math_agent_config (line 170) | def get_math_agent_config() -> AgentConfig:

FILE: cortex/examples/agents/plan_agent.py
  function init_plan_tools (line 17) | async def init_plan_tools() -> ToolSet:
  function make_plan_agent (line 54) | async def make_plan_agent(context_id: str, config: AgentConfig) -> BaseA...
  function get_plan_agent_config (line 61) | def get_plan_agent_config() -> AgentConfig:

FILE: cortex/examples/agents/search_agent.py
  function init_search_tools (line 16) | async def init_search_tools() -> ToolSet:
  function make_search_agent (line 26) | async def make_search_agent(
  function get_search_agent_config (line 37) | def get_search_agent_config() -> AgentConfig:

FILE: cortex/examples/demo_agent_cli.py
  function main (line 31) | async def main():

FILE: cortex/examples/demo_agent_with_orchestrator.py
  function main (line 24) | async def main(

FILE: cortex/examples/demo_agent_with_tool.py
  function add_numbers (line 24) | def add_numbers(a: int, b: int) -> int:
  function multiply_numbers (line 37) | async def multiply_numbers(a: int, b: int) -> int:
  function get_random_string (line 51) | def get_random_string(length: int = 10) -> str:
  function calculate_area (line 63) | def calculate_area(radius: float) -> float:
  function init_tools (line 75) | async def init_tools():
  function main (line 102) | async def main(user_input: str):

FILE: cortex/examples/demo_checkpoint.py
  function make_storage (line 26) | def make_storage() -> CheckpointStorage:
  function get_search_agent_config (line 30) | def get_search_agent_config() -> AgentConfig:
  function get_math_agent_config (line 42) | def get_math_agent_config() -> AgentConfig:
  function make_search_agent (line 54) | async def make_search_agent(
  function make_math_agent (line 70) | async def make_math_agent(
  function make_main_agent (line 85) | async def make_main_agent(
  function main (line 150) | async def main():

FILE: cortex/examples/demo_toolset_channel.py
  class MockExternalServer (line 16) | class MockExternalServer:
    method __init__ (line 19) | def __init__(self):
    method process_request (line 23) | async def process_request(self, tool_name: str, request_id: str, data:...
  function demo_basic_usage (line 69) | async def demo_basic_usage():
  function demo_custom_request_id (line 133) | async def demo_custom_request_id():
  function demo_manual_response (line 179) | async def demo_manual_response():
  function demo_error_handling (line 248) | async def demo_error_handling():
  function demo_concurrent_requests (line 310) | async def demo_concurrent_requests():
  function main (line 362) | async def main():

FILE: cortex/examples/server.py
  function main (line 21) | async def main():

FILE: cortex/model/__init__.py
  class MessageType (line 21) | class MessageType(str, Enum):
  class ModelMessage (line 28) | class ModelMessage(BaseModel):
  class ModelAPI (line 35) | class ModelAPI:
    method __init__ (line 38) | def __init__(self, provider: ModelProvider):
    method chat_completion (line 41) | async def chat_completion(
    method chat_completion_stream (line 70) | async def chat_completion_stream(

FILE: cortex/model/definition.py
  class MessageRole (line 8) | class MessageRole(Enum):
  class ContentBlockType (line 18) | class ContentBlockType(Enum):
  class ModelParams (line 34) | class ModelParams(BaseModel):
  class Function (line 47) | class Function(BaseModel):
  class ChatToolCall (line 60) | class ChatToolCall(BaseModel):
  class ExtraInfo (line 74) | class ExtraInfo(TypedDict, total=False):
  class ChatMessage (line 97) | class ChatMessage(BaseModel):
    method from_dict (line 108) | def from_dict(cls, data: dict) -> "ChatMessage":
    method to_dict (line 111) | def to_dict(self) -> dict:

FILE: cortex/model/provider.py
  class ModelProvider (line 7) | class ModelProvider(ABC):
    method chat_completion_stream (line 9) | async def chat_completion_stream(
    method chat_completion (line 18) | async def chat_completion(

FILE: cortex/model/stepfun_chat.py
  class Function (line 25) | class Function(BaseModel):
  class ToolCall (line 31) | class ToolCall(BaseModel):
  class Message (line 39) | class Message(BaseModel):
  class Delta (line 47) | class Delta(BaseModel):
  class Choice (line 55) | class Choice(BaseModel):
  class StreamChoice (line 62) | class StreamChoice(BaseModel):
  class Usage (line 69) | class Usage(BaseModel):
  class ChatCompletion (line 76) | class ChatCompletion(BaseModel):
  class ChatCompletionChunk (line 86) | class ChatCompletionChunk(BaseModel):
  class StepFunClient (line 98) | class StepFunClient:
    method __init__ (line 107) | def __init__(
    method _build_headers (line 117) | def _build_headers(self) -> dict[str, str]:
    method _build_request_body (line 123) | def _build_request_body(
    method chat_completion (line 149) | async def chat_completion(
    method chat_completion_stream (line 181) | async def chat_completion_stream(

FILE: cortex/model/stepfun_provider.py
  class StepFunModelProvider (line 27) | class StepFunModelProvider(ModelProvider):
    method __init__ (line 34) | def __init__(self, model_params: ModelParams):
    method _call_with_retry (line 42) | async def _call_with_retry(
    method _stream_with_retry (line 77) | async def _stream_with_retry(
    method _create_client (line 107) | def _create_client(self) -> StepFunClient:
    method _chat_messages_to_openai (line 126) | def _chat_messages_to_openai(
    method _extract_think_from_content (line 232) | def _extract_think_from_content(self, content: str | None) -> tuple[st...
    method _message_to_chat_message (line 259) | def _message_to_chat_message(self, message: Message) -> ChatMessage:
    method _process_stream_content_for_think (line 320) | def _process_stream_content_for_think(self, content: str | None) -> tu...
    method _delta_to_chat_message (line 396) | def _delta_to_chat_message(
    method chat_completion (line 458) | async def chat_completion(
    method chat_completion_stream (line 500) | async def chat_completion_stream(

FILE: cortex/model/utils.py
  function merge_delta_message (line 4) | def merge_delta_message(d1: dict | None, d2: dict | None) -> dict:

FILE: cortex/orchestrator/local_runner.py
  class LocalRunner (line 29) | class LocalRunner(Runner):
    method __init__ (line 34) | def __init__(
    method init (line 64) | async def init(
    method send (line 95) | async def send(self, event: AgentEvent) -> None:
    method run (line 118) | async def run(self) -> AsyncGenerator[AgentEvent, None]:
    method _on_agent_finished (line 151) | def _on_agent_finished(self, response: AgentResponse) -> None:
    method _on_generator_complete (line 184) | async def _on_generator_complete(
    method _on_client_tool_send (line 196) | async def _on_client_tool_send(
    method get_result (line 240) | def get_result(self) -> AgentEvent:

FILE: cortex/orchestrator/orchestrator.py
  class OrchMode (line 24) | class OrchMode(str, Enum):
  class Orchestrator (line 31) | class Orchestrator:
    method __init__ (line 34) | def __init__(self, agent_factory: AgentFactory):
    method list_agents (line 52) | def list_agents(self) -> list[AgentConfig]:
    method run (line 56) | async def run(
    method run_root_runner (line 138) | async def run_root_runner(
    method send_event (line 159) | async def send_event(self, event: AgentEvent) -> None:
    method _create_runner (line 172) | async def _create_runner(
    method _handle_client_tool_call (line 203) | async def _handle_client_tool_call(
    method _on_generator_complete (line 284) | async def _on_generator_complete(
    method _cleanup_runner (line 352) | def _cleanup_runner(self, task_id: str) -> None:

FILE: cortex/orchestrator/remote_runner.py
  class RemoteRunner (line 9) | class RemoteRunner(Runner):
    method __init__ (line 12) | def __init__(self, channel: Channel):
    method init (line 23) | async def init(
    method send (line 40) | async def send(self, event: AgentEvent) -> None:
    method run (line 55) | async def run(self) -> AsyncGenerator[AgentEvent, None]:

FILE: cortex/orchestrator/runner.py
  class Runner (line 10) | class Runner(ABC):
    method __init__ (line 13) | def __init__(
    method get_parent_task_id (line 31) | def get_parent_task_id(self) -> str | None:
    method get_root_task_id (line 40) | def get_root_task_id(self) -> str | None:
    method init (line 50) | async def init(
    method send (line 67) | async def send(self, event: AgentEvent) -> None:
    method run (line 77) | async def run(self) -> AsyncGenerator[AgentEvent, None]:
    method get_result (line 87) | def get_result(self) -> AgentEvent:

FILE: cortex/orchestrator/types.py
  class AgentEventType (line 10) | class AgentEventType(str, Enum):
  class AgentRequest (line 21) | class AgentRequest(BaseModel):
  class ClientToolCallType (line 29) | class ClientToolCallType(str, Enum):
  class ClientToolCall (line 37) | class ClientToolCall(BaseModel):
  class AgentEvent (line 46) | class AgentEvent(BaseModel):

FILE: cortex/runtime_config.py
  function _repo_root (line 15) | def _repo_root() -> Path:
  function _pick_first_present (line 20) | def _pick_first_present(cfg: dict[str, Any], keys: tuple[str, ...]) -> Any:
  function _as_int (line 27) | def _as_int(value: Any) -> int | None:
  function load_runtime_config (line 45) | def load_runtime_config() -> dict[str, Any]:
  function get_context_limit_overrides (line 82) | def get_context_limit_overrides() -> tuple[int | None, int | None]:

FILE: cortex/server/channel/channel.py
  class Channel (line 4) | class Channel(ABC):
    method __init__ (line 5) | def __init__(self, context_id: str) -> None:
    method send (line 9) | async def send(self, event: dict[str, object]):
    method receive (line 13) | async def receive(self) -> dict[str, object]:
    method heartbeat (line 17) | async def heartbeat(self):
    method close (line 21) | async def close(self):

FILE: cortex/server/channel/error.py
  class ChannelClosedError (line 1) | class ChannelClosedError(Exception):

FILE: cortex/server/channel/memory_channel.py
  class MemoryChannel (line 10) | class MemoryChannel(Channel):
    method __init__ (line 11) | def __init__(self, context_id: str) -> None:
    method send (line 18) | async def send(self, event: Dict[str, object]):
    method receive (line 24) | async def receive(self) -> Dict[str, object]:
    method heartbeat (line 32) | async def heartbeat(self):
    method close (line 35) | async def close(self):

FILE: cortex/server/channel/ws_channel.py
  class WebSocketChannel (line 16) | class WebSocketChannel(Channel):
    method __init__ (line 20) | def __init__(self, ws: WebSocket) -> None:
    method send (line 23) | async def send(self, event: dict[str, object]) -> None:
    method receive (line 28) | async def receive(self) -> dict[str, object]:
    method heartbeat (line 46) | async def heartbeat(self) -> None:
    method close (line 53) | async def close(self) -> None:

FILE: cortex/server/http_server.py
  function extract_and_set_trace_id (line 25) | def extract_and_set_trace_id(headers: dict) -> str:
  class TraceMiddleware (line 44) | class TraceMiddleware(BaseHTTPMiddleware):
    method dispatch (line 47) | async def dispatch(self, request: Request, call_next):
  class HttpServer (line 54) | class HttpServer:
    method __init__ (line 58) | def __init__(self, orch: Orchestrator, tracer: Tracer):
    method start (line 62) | async def start(self, host: str = "0.0.0.0", port: int = 8001) -> None:
    method _build_app (line 75) | def _build_app(self) -> FastAPI:

FILE: cortex/server/log/log.py
  function setup_logging (line 13) | def setup_logging(log_dir: str = "./logs", log_level: int = logging.WARN...

FILE: cortex/server/log/trace.py
  function set_trace_id (line 7) | def set_trace_id(trace_id: str):
  function get_trace_id (line 11) | def get_trace_id() -> str | None:
  class TraceIdFilter (line 15) | class TraceIdFilter(logging.Filter):
    method filter (line 18) | def filter(self, record: logging.LogRecord) -> bool:

FILE: cortex/tools/agent_tool.py
  class AgentTool (line 16) | class AgentTool(Tool):
    method __init__ (line 21) | def __init__(
    method _define_schema (line 55) | def _define_schema(self) -> ToolSchema:
    method _call (line 101) | async def _call(self, parameters: str, **kwargs) -> Any:
    method parse_messages (line 176) | def parse_messages(parameters: str) -> list[ChatMessage]:

FILE: cortex/tools/base.py
  class ToolSchema (line 11) | class ToolSchema:
  class Tool (line 21) | class Tool(ABC):
    method __init__ (line 24) | def __init__(
    method get_schema (line 45) | def get_schema(self) -> ToolSchema:
    method _define_schema (line 57) | def _define_schema(self) -> ToolSchema:
    method call (line 66) | async def call(self, parameters: str, **kwargs) -> Any:
    method _call (line 80) | async def _call(self, parameters: str, **kwargs) -> Any:

FILE: cortex/tools/channel.py
  class MessageType (line 12) | class MessageType(Enum):
  class ChannelMessage (line 21) | class ChannelMessage:
  class Channel (line 31) | class Channel:
    method __init__ (line 34) | def __init__(
    method set_on_send (line 51) | def set_on_send(
    method create_request_id (line 64) | def create_request_id(self) -> str:
    method send_request (line 74) | async def send_request(
    method set_response (line 145) | def set_response(self, request_id: str, data: Any, error: Optional[str...

FILE: cortex/tools/client_tool.py
  class ClientTool (line 13) | class ClientTool(Tool):
    method __init__ (line 16) | def __init__(
    method _define_schema (line 52) | def _define_schema(self) -> ToolSchema:
    method _call (line 69) | async def _call(self, parameters: str, **kwargs) -> Any:

FILE: cortex/tools/function_tool.py
  class FunctionTool (line 13) | class FunctionTool(Tool):
    method __init__ (line 16) | def __init__(
    method _define_schema (line 35) | def _define_schema(self) -> ToolSchema:
    method _call (line 47) | async def _call(self, parameters: str, **kwargs) -> Any:

FILE: cortex/tools/mcp.py
  class MCPNotInitializedError (line 12) | class MCPNotInitializedError(Exception):
    method __init__ (line 15) | def __init__(self) -> None:
  class MCPClient (line 20) | class MCPClient:
    method __init__ (line 21) | def __init__(self, server_url: str) -> None:
    method initialize (line 26) | async def initialize(self) -> None:
    method aclose (line 37) | async def aclose(self) -> None:
    method list_tools (line 48) | async def list_tools(self) -> list[Tool]:
    method call_tool (line 55) | async def call_tool(

FILE: cortex/tools/mcp_tool.py
  class MCPTool (line 11) | class MCPTool(Tool):
    method __init__ (line 14) | def __init__(
    method _define_schema (line 33) | def _define_schema(self) -> ToolSchema:
    method _call (line 46) | async def _call(self, parameters: str, **kwargs) -> Any:

FILE: cortex/tools/session_tool.py
  class SessionTool (line 9) | class SessionTool(Tool):
    method __init__ (line 12) | def __init__(
    method _define_schema (line 34) | def _define_schema(self) -> ToolSchema:
    method _call (line 55) | async def _call(self, parameters: str, **kwargs) -> Any:

FILE: cortex/tools/toolset.py
  class ToolSet (line 21) | class ToolSet:
    method __init__ (line 26) | def __init__(
    method set_on_send (line 60) | def set_on_send(
    method register (line 75) | def register(self, tool: Tool, name: Optional[str] = None) -> None:
    method register_from_mcp_server (line 95) | async def register_from_mcp_server(
    method register_from_config (line 129) | def register_from_config(self, config: ToolConfig) -> Tool:
    method get_tool (line 175) | def get_tool(self, name: str) -> Optional[Tool]:
    method list_tools (line 187) | def list_tools(self) -> List[str]:
    method call (line 196) | async def call(self, tool_name: str, parameters: str, **kwargs) -> Any:
    method get_schema (line 230) | def get_schema(self, tool_name: str) -> Any:
    method get_all_schemas (line 249) | def get_all_schemas(self) -> Dict[str, Any]:
    method get_client_tool_call_result (line 258) | def get_client_tool_call_result(self, tool_call_id: str) -> Any:
    method set_client_tool_call_result (line 273) | def set_client_tool_call_result(
    method set_response (line 281) | def set_response(self, request_id: str, data: Any, error: Optional[str...

FILE: cortex/tools/types.py
  class ToolParameters (line 10) | class ToolParameters(BaseModel):
  class ToolType (line 17) | class ToolType(Enum):
  class ExecutionType (line 28) | class ExecutionType(Enum):
  class ToolConfig (line 36) | class ToolConfig:

FILE: cortex/tools/ublock_agent_tool.py
  class UnblockAgentTool (line 16) | class UnblockAgentTool(Tool):
    method __init__ (line 21) | def __init__(
    method _define_schema (line 55) | def _define_schema(self) -> ToolSchema:
    method _call (line 101) | async def _call(self, parameters: str, **kwargs) -> Any:
    method parse_messages (line 150) | def parse_messages(parameters: str) -> list[ChatMessage]:

FILE: cortex/tools/unblock_client_tool.py
  class UnblockClientTool (line 13) | class UnblockClientTool(Tool):
    method __init__ (line 16) | def __init__(
    method _define_schema (line 51) | def _define_schema(self) -> ToolSchema:
    method _call (line 68) | async def _call(self, parameters: str, **kwargs) -> Any:

FILE: cortex/tui/tui.py
  function _content_to_string (line 30) | def _content_to_string(content) -> str:
  class EventItem (line 81) | class EventItem(ListItem):
    method __init__ (line 84) | def __init__(self, event: AgentEvent, index: int):
    method render (line 89) | def render(self) -> RenderableType:
  class CommandItem (line 407) | class CommandItem(ListItem):
    method __init__ (line 410) | def __init__(self, command: str):
    method render (line 414) | def render(self) -> RenderableType:
  class AgentItem (line 419) | class AgentItem(ListItem):
    method __init__ (line 422) | def __init__(self, agent_config: AgentConfig):
    method render (line 426) | def render(self) -> RenderableType:
  class ProcessView (line 445) | class ProcessView(Container):
    method __init__ (line 448) | def __init__(self, *args, **kwargs):
    method compose (line 454) | def compose(self) -> ComposeResult:
    method add_event (line 463) | def add_event(self, event: AgentEvent) -> None:
    method on_list_item_selected (line 473) | def on_list_item_selected(self, event: ListView.Selected) -> None:
    method clear_events (line 486) | def clear_events(self) -> None:
  class AgentsListView (line 492) | class AgentsListView(Container):
    method __init__ (line 495) | def __init__(self, *args, **kwargs):
    method set_selection_callback (line 501) | def set_selection_callback(self, callback: Callable[[str], None]) -> N...
    method compose (line 505) | def compose(self) -> ComposeResult:
    method update_agents (line 514) | def update_agents(self, agents: list[AgentConfig]) -> None:
    method on_list_item_selected (line 522) | def on_list_item_selected(self, event: ListView.Selected) -> None:
  class TaskItem (line 539) | class TaskItem(ListItem):
    method __init__ (line 542) | def __init__(self, task_id: str, request_data: dict):
    method render (line 547) | def render(self) -> RenderableType:
  class TasksListView (line 577) | class TasksListView(Container):
    method __init__ (line 580) | def __init__(self, *args, **kwargs):
    method set_selection_callback (line 586) | def set_selection_callback(self, callback: Callable[[str], None]) -> N...
    method compose (line 590) | def compose(self) -> ComposeResult:
    method update_tasks (line 599) | def update_tasks(self, tasks: list[tuple[str, dict]]) -> None:
    method on_list_item_selected (line 611) | def on_list_item_selected(self, event: ListView.Selected) -> None:
  class CommandSelector (line 625) | class CommandSelector(Container):
    method __init__ (line 628) | def __init__(self, *args, **kwargs):
    method compose (line 633) | def compose(self) -> ComposeResult:
    method update_commands (line 636) | def update_commands(self, commands: list[str]) -> None:
    method get_selected_command (line 647) | def get_selected_command(self) -> Optional[str]:
  class AgentTUIApp (line 664) | class AgentTUIApp(App):
    method __init__ (line 752) | def __init__(
    method compose (line 790) | def compose(self) -> ComposeResult:
    method on_mount (line 809) | def on_mount(self) -> None:
    method on_input_changed (line 838) | def on_input_changed(self, event: Input.Changed) -> None:
    method on_command_selected (line 865) | def on_command_selected(self, event: ListView.Selected) -> None:
    method _focus_input (line 875) | def _focus_input(self) -> None:
    method _update_placeholder_by_focus (line 881) | def _update_placeholder_by_focus(self) -> None:
    method on_key (line 892) | def on_key(self, event: Key) -> None:
    method on_input_submitted (line 937) | def on_input_submitted(self, event: Input.Submitted) -> None:
    method _handle_command (line 979) | def _handle_command(self, command: str) -> None:
    method _switch_view (line 1020) | def _switch_view(self, view_name: str) -> None:
    method _on_agent_selected (line 1047) | def _on_agent_selected(self, agent_name: str) -> None:
    method _send_ask_input_result (line 1053) | def _send_ask_input_result(self, user_input: str) -> None:
    method _on_task_selected (line 1100) | def _on_task_selected(self, task_id: str) -> None:
    method _load_tasks (line 1107) | def _load_tasks(self) -> None:
    method _load_task_events (line 1131) | def _load_task_events(self, task_id: str) -> None:
    method _save_request (line 1163) | def _save_request(self, root_task_id: str, request: AgentRequest) -> N...
    method _save_event (line 1176) | def _save_event(self, root_task_id: str, event: AgentEvent) -> None:
    method _run_agent (line 1190) | async def _run_agent(self, user_input: str) -> None:
    method action_quit (line 1280) | async def action_quit(self) -> None:

FILE: cortex/utils/generator_merger.py
  class GeneratorMerger (line 8) | class GeneratorMerger:
    method __init__ (line 11) | def __init__(
    method add_generator (line 35) | def add_generator(
    method add_async_generator (line 58) | def add_async_generator(
    method _get_next_item (line 79) | def _get_next_item(self, generator: Generator[Any, None, None]) -> tup...
    method _run_generator_with_wrapper (line 95) | async def _run_generator_with_wrapper(
    method _run_generator (line 131) | async def _run_generator(
    method _run_async_generator (line 164) | async def _run_async_generator(
    method _notify_generator_complete (line 189) | async def _notify_generator_complete(
    method merge (line 229) | async def merge(self) -> AsyncGenerator[Any, None]:
    method __aiter__ (line 349) | async def __aiter__(self):
  function example_usage (line 355) | async def example_usage():

FILE: cortex/utils/generator_merger_examples.py
  function example_1_basic_usage (line 9) | async def example_1_basic_usage():
  function example_2_dynamic_addition (line 34) | async def example_2_dynamic_addition():
  function example_3_different_data_types (line 66) | async def example_3_different_data_types():
  function example_4_data_streams (line 100) | async def example_4_data_streams():
  function example_5_file_processing (line 145) | async def example_5_file_processing():
  function example_6_batch_processing (line 175) | async def example_6_batch_processing():
  function example_7_error_handling (line 211) | async def example_7_error_handling():
  function example_8_callback_usage (line 249) | async def example_8_callback_usage():
  function example_9_callback_vs_event (line 321) | async def example_9_callback_vs_event():
  function run_all_examples (line 369) | async def run_all_examples():

FILE: demo/dr_agent/dr_agent.py
  function init_dr_tools (line 28) | async def init_dr_tools(context_id: str | None = None) -> ToolSet:
  function make_dr_agent (line 67) | async def make_dr_agent(
  function get_dr_agent_config (line 99) | def get_dr_agent_config() -> AgentConfig:

FILE: demo/server.py
  function parse_args (line 14) | def parse_args():
  function main (line 25) | async def main():

FILE: demo/tools/batch_open.py
  function _generate_unique_name (line 17) | def _generate_unique_name() -> str:
  class BatchOpenResult (line 22) | class BatchOpenResult(TypedDict):
  function batch_open (line 31) | async def batch_open(urls: list[str]) -> BatchOpenResult:
  function format_open_results (line 74) | def format_open_results(result: BatchOpenResult) -> str:

FILE: demo/tools/batch_search.py
  function _generate_cite_index (line 19) | def _generate_cite_index(query_idx: int, item_idx: int, url: str) -> str:
  class BatchSearchResult (line 25) | class BatchSearchResult(TypedDict):
  function _deduplicate_results (line 30) | def _deduplicate_results(search_results: list[SearchResult]) -> None:
  function _rerank (line 48) | def _rerank(search_results: list[SearchResult], topk: int) -> None:
  function batch_search (line 92) | async def batch_search(
  function _generate_unique_name (line 130) | def _generate_unique_name() -> str:
  function format_search_results (line 135) | def format_search_results(result: BatchSearchResult) -> str:

FILE: demo/tools/batch_web_surfer.py
  function _ensure_list (line 12) | def _ensure_list(value: list[str] | str | None) -> list[str]:
  function batch_web_surfer (line 31) | async def batch_web_surfer(
  function create_batch_web_surfer_tool (line 102) | def create_batch_web_surfer_tool():

FILE: demo/tools/file.py
  function _wrap_tool_result (line 22) | def _wrap_tool_result(text: str) -> list[dict]:
  function _safe_decode (line 36) | def _safe_decode(data: bytes, encoding: str) -> tuple[str, bool]:
  function _format_bytes (line 45) | def _format_bytes(size: int) -> str:
  function _format_read_result (line 55) | def _format_read_result(
  function _format_write_result (line 79) | def _format_write_result(path: Path, action: str, size: int) -> str:
  function _format_stat_result (line 89) | def _format_stat_result(path: Path, stat_result: os.stat_result) -> str:
  function _format_list_result (line 106) | def _format_list_result(path: Path, entries: list[os.DirEntry]) -> str:
  function file (line 129) | async def file(
  function create_file_tool (line 236) | def create_file_tool() -> FunctionTool:

FILE: demo/tools/open.py
  class Page (line 19) | class Page(TypedDict, total=False):
  class OpenResult (line 32) | class OpenResult(TypedDict):
  function _make_error_result (line 39) | def _make_error_result(code: int, message: str, url: str) -> OpenResult:
  function _download_http (line 48) | async def _download_http(url: str, timeout: int = _OPEN_URL_TIMEOUT) -> ...
  function _download_s3 (line 64) | def _download_s3(url: str) -> bytes:
  function _get_url_content_bytes (line 70) | async def _get_url_content_bytes(url: str, timeout: int = _OPEN_URL_TIME...
  function _parse_content_to_markdown (line 83) | def _parse_content_to_markdown(content_bytes: bytes, url: str) -> str:
  function open (line 94) | async def open(url: str) -> OpenResult:

FILE: demo/tools/search.py
  class SearchResultItem (line 8) | class SearchResultItem(TypedDict):
  class SearchResult (line 17) | class SearchResult(TypedDict):
  function search (line 28) | async def search(

FILE: demo/tools/shell.py
  class ShellOutput (line 28) | class ShellOutput:
  function _truncate_from_end (line 36) | def _truncate_from_end(content: str, max_length: int = MAX_OUTPUT_LENGTH...
  function _format_shell_output (line 43) | def _format_shell_output(
  function _execute_shell (line 91) | async def _execute_shell(
  function shell (line 147) | async def shell(
  function create_shell_tool (line 187) | def create_shell_tool() -> FunctionTool:

FILE: demo/tools/text_truncator.py
  function truncate_text (line 11) | def truncate_text(
  function _find_sentence_boundary (line 67) | def _find_sentence_boundary(text: str, min_position: float) -> int:
  function clean_text_whitespace (line 92) | def clean_text_whitespace(text: str, max_consecutive_newlines: int = 3) ...
  function clean_markdown_content (line 116) | def clean_markdown_content(text: str) -> str:
  class FormatResult (line 141) | class FormatResult:
  function format_content (line 148) | def format_content(

FILE: demo/tools/todo.py
  function _ensure_todo_dir (line 81) | def _ensure_todo_dir():
  class TodoItemHint (line 87) | class TodoItemHint(TypedDict):
  class TodoItem (line 111) | class TodoItem:
    method __post_init__ (line 117) | def __post_init__(self):
    method update (line 126) | def update(self, updates: dict[str, Any]) -> None:
  class TodoCollection (line 134) | class TodoCollection:
    method merge_updates (line 139) | def merge_updates(self, updates: UPDATE_TYPE) -> None:
    method to_dict (line 149) | def to_dict(self) -> dict[str, dict[str, Any]]:
    method from_dict (line 154) | def from_dict(cls, data: dict[str, dict[str, Any]]) -> "TodoCollection":
  function format_todo_result (line 162) | def format_todo_result(todos: TodoCollection) -> tuple[str, dict[str, An...
  function _append_field_line (line 236) | def _append_field_line(lines: list[str], field_name: str, value: Any) ->...
  function seems_like_complete_rewrite (line 260) | def seems_like_complete_rewrite(updates: UPDATE_TYPE, current: dict[str,...
  function create_todo_tool (line 272) | def create_todo_tool(context_id: str = "default"):

FILE: demo/tools/utils.py
  function json_dumps (line 11) | def json_dumps(data: Any, indent: int = 2, ensure_ascii: bool = False) -...

FILE: scripts/runner.py
  class EvalTask (line 44) | class EvalTask:
  function slugify (line 54) | def slugify(value: str | None, fallback_prefix: str = "task") -> str:
  function _truncate (line 65) | def _truncate(text: str, limit: int | None = 600) -> str:
  function _stringify_content (line 73) | def _stringify_content(content: Any) -> str:
  function _format_content_blocks (line 102) | def _format_content_blocks(
  function _format_tool_calls (line 132) | def _format_tool_calls(tool_calls: list[ChatToolCall] | None) -> list[di...
  function _extract_answer_text (line 147) | def _extract_answer_text(content: Any) -> str | None:
  function _format_message (line 159) | def _format_message(
  function _format_event (line 180) | def _format_event(event: AgentEvent, index: int, max_block_chars: int | ...
  function load_tasks_from_file (line 224) | def load_tasks_from_file(path: Path) -> list[EvalTask]:
  function merge_tasks (line 269) | def merge_tasks(
  function build_orchestrator (line 301) | def build_orchestrator(agent_name: str) -> Orchestrator:
  function build_agent_config (line 312) | def build_agent_config(
  function run_single_task (line 337) | async def run_single_task(
  function save_result (line 469) | def save_result(
  function run_tasks (line 513) | async def run_tasks(
  function parse_args (line 553) | def parse_args() -> argparse.Namespace:
  function configure_logging (line 626) | def configure_logging(level: str) -> None:
  function load_config_file (line 633) | def load_config_file(path: str | Path) -> dict[str, Any]:
  function merge_with_config (line 642) | def merge_with_config(
  function main (line 664) | def main() -> None: