flare-kernel 1.0.7__tar.gz → 1.0.8__tar.gz

{flare_kernel-1.0.7 → flare_kernel-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flare-kernel
-Version: 1.0.7
+Version: 1.0.8
 Summary: FLARE kernel runtime package
 License: Proprietary
 Classifier: Development Status :: 3 - Alpha

{flare_kernel-1.0.7 → flare_kernel-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flare-kernel"
-version = "1.0.7"
+version = "1.0.8"
 description = "FLARE kernel runtime package"
 readme = "README.md"
 requires-python = ">=3.11"

{flare_kernel-1.0.7 → flare_kernel-1.0.8}/src/flare_kernel/contracts/session_contract.py

@@ -96,8 +96,18 @@ class SessionMessageRecord(BaseModel):
     created_at: str
 
 
+class SessionMessageWindow(BaseModel):
+    """Pagination metadata for a loaded message window."""
+
+    mode: Literal["full", "latest", "before"] = "full"
+    limit: int | None = None
+    has_older: bool = False
+    next_before: str = ""
+
+
 class SessionMessageListResponse(BaseModel):
     messages: list[SessionMessageRecord] = Field(default_factory=list)
+    window: SessionMessageWindow = Field(default_factory=SessionMessageWindow)
 
 
 class SessionReplayTurn(BaseModel):

{flare_kernel-1.0.7 → flare_kernel-1.0.8}/src/flare_kernel/router/api/session.py

@@ -11,11 +11,9 @@ from fastapi import APIRouter, Depends, Query
 
 from flare_kernel.contracts import (
     AuthContext,
-    SessionAppendExchangeRequest,
     SessionCreateRequest,
     SessionLifecycleRequest,
     SessionListResponse,
-    SessionMessageListResponse,
     SessionRecord,
     SessionReplayResponse,
     SessionUpdateRequest,
@@ -27,18 +25,19 @@ from flare_kernel.router.api.auth_guard import (
     require_route_scope,
     resolve_route_auth_context,
 )
-from flare_kernel.router.api.errors import ApiError
-from flare_kernel.router.api.session_artifact_edit import resolve_artifact_edit_append_fields
+from flare_kernel.router.api.session_access import (
+    invalid_lifecycle_error,
+    require_session_or_404,
+    require_session_scope,
+)
 from flare_kernel.router.api.session_list_events import publish_session_list_invalidation
+from flare_kernel.router.api.session_messages import router as session_messages_router
 from flare_kernel.router.api.session_run_projection import project_session_run_metadata
 from flare_kernel.session_replay import build_session_replay
 from flare_kernel.session_store import (
     apply_lifecycle_action,
-    append_exchange,
     create_session,
     ensure_session,
-    get_session,
-    list_messages,
     update_session,
 )
 from flare_kernel.session_list_store import list_session_list_items
@@ -46,56 +45,6 @@ from flare_kernel.session_list_store import list_session_list_items
 router = APIRouter(tags=["sessions"])
 
 
-def _require_session_or_404(session_id: str) -> dict:
-    record = get_session(session_id=session_id)
-    if record is not None:
-        return record
-    raise ApiError(
-        code="RESOURCE_NOT_FOUND",
-        http_status=404,
-        message="session not found",
-        description="target session_id does not exist",
-        context_fields=["session_id"],
-        retryable=False,
-        details={"session_id": session_id},
-    )
-
-
-def _require_session_scope(
-    auth_context: AuthContext | None,
-    record: dict,
-    required_scopes: list[str],
-) -> None:
-    require_route_scope(
-        auth_context,
-        required_scopes=required_scopes,
-        project_id=str(record.get("project_id") or ""),
-        session_id=str(record.get("session_id") or ""),
-        user_id=str(record.get("user_id") or ""),
-    )
-
-
-def _invalid_lifecycle_error(exc: ValueError, fields: list[str]) -> ApiError:
-    """Map lifecycle policy validation failures to the API error contract.
-
-    Args:
-        exc: Policy validation exception raised by session lifecycle helpers.
-        fields: Request fields responsible for the validation failure.
-
-    Returns:
-        ApiError with the shared structured error payload fields.
-    """
-
-    return ApiError(
-        code="INVALID_SESSION_LIFECYCLE",
-        http_status=422,
-        message="invalid session lifecycle",
-        description=str(exc),
-        context_fields=fields,
-        retryable=False,
-    )
-
-
 @router.get("/sessions", response_model=SessionListResponse)
 @router.get("/chat/sessions", response_model=SessionListResponse)
 async def list_chat_sessions(
@@ -140,7 +89,7 @@ async def list_chat_sessions(
             include_context=include_context,
         )
     except ValueError as exc:
-        raise _invalid_lifecycle_error(exc, ["status"]) from exc
+        raise invalid_lifecycle_error(exc, ["status"]) from exc
     return SessionListResponse(sessions=[SessionRecord.model_validate(project_session_run_metadata(row)) for row in rows])
 
 
@@ -175,8 +124,8 @@ async def get_chat_session(
     session_id: str,
     auth_context: AuthContext | None = Depends(resolve_route_auth_context),
 ) -> SessionRecord:
-    record = _require_session_or_404(session_id)
-    _require_session_scope(auth_context, record, ["sessions:read"])
+    record = require_session_or_404(session_id)
+    require_session_scope(auth_context, record, ["sessions:read"])
     return SessionRecord.model_validate(project_session_run_metadata(record))
 
 
@@ -197,8 +146,8 @@ async def patch_chat_session(
         Updated session record.
     """
 
-    record = _require_session_or_404(session_id)
-    _require_session_scope(auth_context, record, ["sessions:write"])
+    record = require_session_or_404(session_id)
+    require_session_scope(auth_context, record, ["sessions:write"])
     try:
         row = update_session(
             session_id=session_id,
@@ -209,23 +158,12 @@ async def patch_chat_session(
             title_source=req.title_source,
         )
     except ValueError as exc:
-        raise _invalid_lifecycle_error(exc, ["status"]) from exc
-    next_row = row or _require_session_or_404(session_id)
+        raise invalid_lifecycle_error(exc, ["status"]) from exc
+    next_row = row or require_session_or_404(session_id)
     publish_session_list_invalidation("updated")
     return SessionRecord.model_validate(next_row)
 
 
-@router.get("/sessions/{session_id}/messages", response_model=SessionMessageListResponse)
-@router.get("/chat/sessions/{session_id}/messages", response_model=SessionMessageListResponse)
-async def list_chat_session_messages(
-    session_id: str,
-    auth_context: AuthContext | None = Depends(resolve_route_auth_context),
-) -> SessionMessageListResponse:
-    record = _require_session_or_404(session_id)
-    _require_session_scope(auth_context, record, ["sessions:read"])
-    return SessionMessageListResponse(messages=list_messages(session_id=session_id))
-
-
 @router.get("/sessions/{session_id}/replay", response_model=SessionReplayResponse)
 @router.get("/chat/sessions/{session_id}/replay", response_model=SessionReplayResponse)
 async def get_chat_session_replay(
@@ -243,10 +181,10 @@ async def get_chat_session_replay(
 
     replay = build_session_replay(session_id=session_id)
     if replay is None:
-        record = _require_session_or_404(session_id)
+        record = require_session_or_404(session_id)
     else:
         record = dict(replay.get("session") or {})
-    _require_session_scope(auth_context, record, ["sessions:read"])
+    require_session_scope(auth_context, record, ["sessions:read"])
     return SessionReplayResponse.model_validate(replay)
 
 
@@ -267,69 +205,17 @@ async def apply_chat_session_lifecycle(
         Updated session record after the lifecycle transition.
     """
 
-    record = _require_session_or_404(session_id)
-    _require_session_scope(auth_context, record, ["sessions:write"])
+    record = require_session_or_404(session_id)
+    require_session_scope(auth_context, record, ["sessions:write"])
     try:
         row = apply_lifecycle_action(session_id=session_id, action=req.action)
     except ValueError as exc:
-        raise _invalid_lifecycle_error(exc, ["action"]) from exc
-    next_row = row or _require_session_or_404(session_id)
+        raise invalid_lifecycle_error(exc, ["action"]) from exc
+    next_row = row or require_session_or_404(session_id)
     publish_session_list_invalidation(str(req.action or "").strip() or "lifecycle")
     return SessionRecord.model_validate(next_row)
 
 
-@router.post("/sessions/{session_id}/messages", response_model=SessionRecord)
-@router.post("/chat/sessions/{session_id}/messages", response_model=SessionRecord)
-async def append_chat_session_exchange(
-    session_id: str,
-    req: SessionAppendExchangeRequest,
-    auth_context: AuthContext | None = Depends(resolve_route_auth_context),
-) -> SessionRecord:
-    record = _require_session_or_404(session_id)
-    _require_session_scope(auth_context, record, ["sessions:write"])
-    append_fields = resolve_artifact_edit_append_fields(
-        artifact_edit_request=req.artifact_edit_request,
-        default_mode_key=str(record.get("function_type") or ""),
-        canvas_state=req.canvas_state,
-        analysis_payload=req.analysis_payload,
-        context_patch=req.context_patch,
-        execution_trace=req.execution_trace,
-        plan_payload=req.plan_payload,
-    )
-    row = append_exchange(
-        session_id=session_id,
-        run_id=req.run_id,
-        user_message=req.user_message,
-        assistant_message=req.assistant_message,
-        replace_assistant_message_id=req.replace_assistant_message_id,
-        attachments=req.attachments,
-        context_refs=req.context_refs,
-        knowledge_refs=req.knowledge_refs,
-        agent_status=req.agent_status,
-        thinking_trace=req.thinking_trace,
-        execution_trace=append_fields["execution_trace"],
-        knowledge_search=req.knowledge_search,
-        sourcing_candidates=req.sourcing_candidates,
-        knowledge_citation=req.knowledge_citation,
-        canvas_state=append_fields["canvas_state"],
-        analysis_payload=append_fields["analysis_payload"],
-        context_usage=req.context_usage,
-        provider_trace=req.provider_trace,
-        context_activity=req.context_activity,
-        context_authority=req.context_authority,
-        workflow_projection=req.workflow_projection,
-        plan_payload=append_fields["plan_payload"],
-        reasoning_result=req.reasoning_result,
-        document_result=req.document_result,
-        track_result=req.track_result,
-        context_patch=append_fields["context_patch"],
-        context_snapshot=req.context_snapshot,
-    )
-    next_row = row or _require_session_or_404(session_id)
-    publish_session_list_invalidation("message_appended")
-    return SessionRecord.model_validate(next_row)
-
-
 @router.post("/sessions/ensure", response_model=SessionRecord)
 @router.post("/chat/sessions/ensure", response_model=SessionRecord)
 async def ensure_chat_session(
@@ -356,3 +242,6 @@ async def ensure_chat_session(
     )
     publish_session_list_invalidation("ensured")
     return SessionRecord.model_validate(row)
+
+
+router.include_router(session_messages_router)

flare_kernel-1.0.8/src/flare_kernel/router/api/session_access.py

@@ -0,0 +1,48 @@
+"""Session route access helpers."""
+
+from __future__ import annotations
+
+from flare_kernel.contracts import AuthContext
+from flare_kernel.router.api.auth_guard import require_route_scope
+from flare_kernel.router.api.errors import ApiError
+from flare_kernel.session_store import get_session
+
+
+def require_session_or_404(session_id: str) -> dict:
+    record = get_session(session_id=session_id)
+    if record is not None:
+        return record
+    raise ApiError(
+        code="RESOURCE_NOT_FOUND",
+        http_status=404,
+        message="session not found",
+        description="target session_id does not exist",
+        context_fields=["session_id"],
+        retryable=False,
+        details={"session_id": session_id},
+    )
+
+
+def require_session_scope(
+    auth_context: AuthContext | None,
+    record: dict,
+    required_scopes: list[str],
+) -> None:
+    require_route_scope(
+        auth_context,
+        required_scopes=required_scopes,
+        project_id=str(record.get("project_id") or ""),
+        session_id=str(record.get("session_id") or ""),
+        user_id=str(record.get("user_id") or ""),
+    )
+
+
+def invalid_lifecycle_error(exc: ValueError, fields: list[str]) -> ApiError:
+    return ApiError(
+        code="INVALID_SESSION_LIFECYCLE",
+        http_status=422,
+        message="invalid session lifecycle",
+        description=str(exc),
+        context_fields=fields,
+        retryable=False,
+    )

flare_kernel-1.0.8/src/flare_kernel/router/api/session_messages.py

@@ -0,0 +1,101 @@
+"""Session message API routes."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, Query
+
+from flare_kernel.contracts import AuthContext, SessionAppendExchangeRequest, SessionMessageListResponse, SessionRecord
+from flare_kernel.router.api.auth_guard import resolve_route_auth_context
+from flare_kernel.router.api.errors import ApiError
+from flare_kernel.router.api.session_access import require_session_or_404, require_session_scope
+from flare_kernel.router.api.session_artifact_edit import resolve_artifact_edit_append_fields
+from flare_kernel.router.api.session_list_events import publish_session_list_invalidation
+from flare_kernel.session_message_window_store import list_message_window
+from flare_kernel.session_store import append_exchange
+
+router = APIRouter(tags=["sessions"])
+
+
+def _invalid_message_cursor_error(exc: ValueError) -> ApiError:
+    return ApiError(
+        code="INVALID_MESSAGE_CURSOR",
+        http_status=422,
+        message="invalid message cursor",
+        description=str(exc),
+        context_fields=["before", "cursor"],
+        retryable=False,
+    )
+
+
+@router.get("/sessions/{session_id}/messages", response_model=SessionMessageListResponse)
+@router.get("/chat/sessions/{session_id}/messages", response_model=SessionMessageListResponse)
+async def list_chat_session_messages(
+    session_id: str,
+    limit: int = Query(default=0, ge=0, le=200),
+    before: str = Query(default=""),
+    cursor: str = Query(default=""),
+    auth_context: AuthContext | None = Depends(resolve_route_auth_context),
+) -> SessionMessageListResponse:
+    record = require_session_or_404(session_id)
+    require_session_scope(auth_context, record, ["sessions:read"])
+    try:
+        payload = list_message_window(
+            session_id=session_id,
+            limit=limit,
+            before=str(before or cursor or ""),
+        )
+    except ValueError as exc:
+        raise _invalid_message_cursor_error(exc) from exc
+    return SessionMessageListResponse.model_validate(payload)
+
+
+@router.post("/sessions/{session_id}/messages", response_model=SessionRecord)
+@router.post("/chat/sessions/{session_id}/messages", response_model=SessionRecord)
+async def append_chat_session_exchange(
+    session_id: str,
+    req: SessionAppendExchangeRequest,
+    auth_context: AuthContext | None = Depends(resolve_route_auth_context),
+) -> SessionRecord:
+    record = require_session_or_404(session_id)
+    require_session_scope(auth_context, record, ["sessions:write"])
+    append_fields = resolve_artifact_edit_append_fields(
+        artifact_edit_request=req.artifact_edit_request,
+        default_mode_key=str(record.get("function_type") or ""),
+        canvas_state=req.canvas_state,
+        analysis_payload=req.analysis_payload,
+        context_patch=req.context_patch,
+        execution_trace=req.execution_trace,
+        plan_payload=req.plan_payload,
+    )
+    row = append_exchange(
+        session_id=session_id,
+        run_id=req.run_id,
+        user_message=req.user_message,
+        assistant_message=req.assistant_message,
+        replace_assistant_message_id=req.replace_assistant_message_id,
+        attachments=req.attachments,
+        context_refs=req.context_refs,
+        knowledge_refs=req.knowledge_refs,
+        agent_status=req.agent_status,
+        thinking_trace=req.thinking_trace,
+        execution_trace=append_fields["execution_trace"],
+        knowledge_search=req.knowledge_search,
+        sourcing_candidates=req.sourcing_candidates,
+        knowledge_citation=req.knowledge_citation,
+        canvas_state=append_fields["canvas_state"],
+        analysis_payload=append_fields["analysis_payload"],
+        context_usage=req.context_usage,
+        provider_trace=req.provider_trace,
+        context_activity=req.context_activity,
+        context_authority=req.context_authority,
+        workflow_projection=req.workflow_projection,
+        plan_payload=append_fields["plan_payload"],
+        reasoning_result=req.reasoning_result,
+        document_result=req.document_result,
+        track_result=req.track_result,
+        context_patch=append_fields["context_patch"],
+        context_snapshot=req.context_snapshot,
+    )
+    next_row = row or require_session_or_404(session_id)
+    publish_session_list_invalidation("message_appended")
+    return SessionRecord.model_validate(next_row)

{flare_kernel-1.0.7 → flare_kernel-1.0.8}/src/flare_kernel/router/canonical/workflow_projection.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any
 
 from flare_kernel.router.canonical.workflow_projection_policy import build_workflow_projection_policy
+from flare_kernel.router.canonical.workflow_run_projection import build_workflow_run_projection
 
 
 def _mapping(value: Any) -> dict[str, Any]:
@@ -249,11 +250,15 @@ def build_workflow_projection(
         patch_status=status,
     )
     turn_disposition = _turn_disposition(orchestration_status, runtime)
+    run_projection = build_workflow_run_projection(runtime)
     return {
         "mode": _text(source.get("mode_key")),
         "phase": _phase(source),
         "run_id": _runtime_run_id(runtime),
-        "run_events": _runtime_run_events(runtime),
+        "run_state": run_projection["run_state"],
+        "current_step": run_projection["current_step"],
+        "run_steps": run_projection["run_steps"],
+        "run_events": run_projection["run_events"] or _runtime_run_events(runtime),
         "readiness": policy["readiness"],
         "turn_disposition": _text(turn_disposition.get("turn_disposition")),
         "artifact_write_allowed": turn_disposition.get("artifact_write_allowed") is True,

flare_kernel-1.0.8/src/flare_kernel/router/canonical/workflow_run_projection.py

@@ -0,0 +1,166 @@
+"""Canonical workflow Run status projection from backend RunEvents."""
+
+from __future__ import annotations
+
+from typing import Any
+
+_TERMINAL_EVENT_STATUS = {
+    "complete": "completed",
+    "error": "failed",
+    "run.completed": "completed",
+    "run.failed": "failed",
+    "run.cancelled": "cancelled",
+}
+
+_STEP_EVENT_STATUS = {
+    "workstep.started": "running",
+    "workstep.progress": "running",
+    "capability.called": "running",
+    "capability.result_normalized": "completed",
+    "workstep.completed": "completed",
+    "workstep.blocked": "blocked",
+    "workstep.failed": "failed",
+    "human_confirmation.requested": "waiting_for_user",
+}
+
+_ACTIVE_RUN_STATES = frozenset({"queued", "running", "waiting_for_user"})
+
+
+def _mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _sequence(value: Any) -> list[Any]:
+    return value if isinstance(value, list) else []
+
+
+def _text(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _number(value: Any, fallback: int = 0) -> int:
+    try:
+        return int(value or fallback)
+    except (TypeError, ValueError):
+        return fallback
+
+
+def _normalized_events(runtime_snapshot: dict[str, Any]) -> list[dict[str, Any]]:
+    events = []
+    for index, item in enumerate(_sequence(runtime_snapshot.get("run_events")), start=1):
+        event = _mapping(item)
+        payload = _mapping(event.get("payload"))
+        event_name = _text(event.get("event_name") or event.get("eventName") or payload.get("event_name"))
+        if not event_name:
+            continue
+        events.append(
+            {
+                **dict(event),
+                "event_name": event_name,
+                "payload": dict(payload),
+                "sequence": _number(event.get("sequence") or payload.get("run_event_sequence"), index),
+            }
+        )
+    return sorted(events, key=lambda event: _number(event.get("sequence")))
+
+
+def _event_step_id(event: dict[str, Any]) -> str:
+    payload = _mapping(event.get("payload"))
+    return _text(payload.get("step_id") or payload.get("stepId"))
+
+
+def _step_status(event: dict[str, Any]) -> str:
+    payload = _mapping(event.get("payload"))
+    payload_status = _text(payload.get("step_status") or payload.get("status"))
+    event_name = _text(event.get("event_name"))
+    if payload_status in {"blocked", "failed", "completed", "cancelled", "waiting_for_user"}:
+        return payload_status
+    return _STEP_EVENT_STATUS.get(event_name, "")
+
+
+def _capability_id(event: dict[str, Any], step: dict[str, Any]) -> str:
+    payload = _mapping(event.get("payload"))
+    return _text(payload.get("capability_id") or payload.get("owner_capability") or step.get("capability_id"))
+
+
+def _merge_step_event(step: dict[str, Any], event: dict[str, Any]) -> dict[str, Any]:
+    payload = _mapping(event.get("payload"))
+    return {
+        **step,
+        "step_id": _event_step_id(event) or _text(step.get("step_id")),
+        "status": _step_status(event) or _text(step.get("status")),
+        "capability_id": _capability_id(event, step),
+        "owner_capability": _text(payload.get("owner_capability") or step.get("owner_capability")),
+        "reason": _text(payload.get("capability_reason") or payload.get("reason") or step.get("reason")),
+        "missing_inputs": [_text(item) for item in _sequence(payload.get("missing_inputs")) if _text(item)],
+        "latest_event_name": _text(event.get("event_name")),
+        "sequence": _number(event.get("sequence")),
+    }
+
+
+def _run_steps(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    steps_by_id: dict[str, dict[str, Any]] = {}
+    for event in events:
+        step_id = _event_step_id(event)
+        if not step_id or not _step_status(event):
+            continue
+        steps_by_id[step_id] = _merge_step_event(steps_by_id.get(step_id, {}), event)
+    return sorted(steps_by_id.values(), key=lambda step: _number(step.get("sequence")))
+
+
+def _terminal_event_state(events: list[dict[str, Any]]) -> str:
+    for event in reversed(events):
+        status = _TERMINAL_EVENT_STATUS.get(_text(event.get("event_name")), "")
+        if status:
+            return status
+    return ""
+
+
+def _payload_run_state(events: list[dict[str, Any]]) -> str:
+    for event in reversed(events):
+        payload = _mapping(event.get("payload"))
+        state = _text(payload.get("run_state"))
+        if state:
+            return state
+    return ""
+
+
+def _run_state(runtime_snapshot: dict[str, Any], events: list[dict[str, Any]]) -> str:
+    terminal = _terminal_event_state(events)
+    if terminal:
+        return terminal
+    run = _mapping(runtime_snapshot.get("run"))
+    run_state = _text(run.get("state") or run.get("run_state"))
+    if run_state:
+        return run_state
+    payload_state = _payload_run_state(events)
+    if payload_state:
+        return payload_state
+    return "running" if events else ""
+
+
+def _current_step(steps: list[dict[str, Any]], run_state: str) -> dict[str, Any]:
+    active = [step for step in steps if _text(step.get("status")) in _ACTIVE_RUN_STATES]
+    if active:
+        return dict(active[-1])
+    if run_state in _ACTIVE_RUN_STATES and steps:
+        return dict(steps[-1])
+    return dict(steps[-1]) if steps else {}
+
+
+def build_workflow_run_projection(runtime_snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Return backend-owned current Run status plus append-only events."""
+
+    runtime = _mapping(runtime_snapshot)
+    events = _normalized_events(runtime)
+    steps = _run_steps(events)
+    state = _run_state(runtime, events)
+    return {
+        "run_state": state,
+        "current_step": _current_step(steps, state),
+        "run_steps": steps,
+        "run_events": events,
+    }
+
+
+__all__ = ["build_workflow_run_projection"]

{flare_kernel-1.0.7 → flare_kernel-1.0.8}/src/flare_kernel/runtime/infrastructure/session/repository.py

@@ -18,6 +18,15 @@ class SessionRepository(Protocol):
 
     def list_session_messages(self, session_id: str) -> list[dict[str, Any]]: ...
 
+    def list_session_messages_descending(
+        self,
+        session_id: str,
+        *,
+        before_created_at: str = "",
+        before_message_id: str = "",
+        limit: int = 50,
+    ) -> list[dict[str, Any]]: ...
+
     def append_session_messages(self, session_id: str, messages: list[dict[str, Any]]) -> list[dict[str, Any]]: ...
 
     def replace_session_message(self, session_id: str, message_id: str, message: dict[str, Any]) -> list[dict[str, Any]]: ...

{flare_kernel-1.0.7 → flare_kernel-1.0.8}/src/flare_kernel/runtime/infrastructure/session/repository_memory.py

@@ -49,6 +49,32 @@ class InMemorySessionRepository(SessionRepository):
         with self._lock:
             return [dict(item) for item in self._messages.get(resolved, [])]
 
+    def list_session_messages_descending(
+        self,
+        session_id: str,
+        *,
+        before_created_at: str = "",
+        before_message_id: str = "",
+        limit: int = 50,
+    ) -> list[dict[str, Any]]:
+        resolved = str(session_id or "").strip()
+        bounded_limit = max(0, int(limit or 0))
+        if not resolved or bounded_limit <= 0:
+            return []
+        cursor = (str(before_created_at or "").strip(), str(before_message_id or "").strip())
+        with self._lock:
+            messages = sorted(
+                [dict(item) for item in self._messages.get(resolved, [])],
+                key=lambda item: (str(item.get("created_at") or ""), str(item.get("message_id") or "")),
+                reverse=True,
+            )
+        if all(cursor):
+            messages = [
+                item for item in messages
+                if (str(item.get("created_at") or ""), str(item.get("message_id") or "")) < cursor
+            ]
+        return messages[:bounded_limit]
+
     def append_session_messages(self, session_id: str, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
         resolved = str(session_id or "").strip()
         if not resolved: