fastworkflow 3.0.1__tar.gz → 3.1.2__tar.gz

{fastworkflow-3.0.1 → fastworkflow-3.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 3.0.1
+Version: 3.1.2
 Summary: A framework for rapidly building large-scale, deterministic, interactive workflows with a fault-tolerant, conversational UX
 License: Apache-2.0
 Keywords: fastworkflow,ai,workflow,llm,openai
@@ -15,7 +15,7 @@ Provides-Extra: training
 Requires-Dist: aiohttp (>=3.14.3)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: cryptography (>=50.0.0)
-Requires-Dist: datasets (>=4.0.0,<5.0.0) ; extra == "training"
+Requires-Dist: datasets (>=5.0.1,<6.0.0) ; extra == "training"
 Requires-Dist: dspy (>=3.0.1,<4.0.0)
 Requires-Dist: fastapi (>=0.120.1) ; extra == "server" or extra == "fastapi"
 Requires-Dist: fastapi-mcp (>=0.4.0,<0.5.0) ; extra == "server" or extra == "fastapi"
@@ -626,6 +626,7 @@ Two files per workflow (templates ship with `fastworkflow examples fetch`).
 | `LLM_PLANNER` | Model for the agent's task planner | `run` (agent) | `mistral/mistral-small-latest` |
 | `LLM_AGENT` | Model for the DSPy agent | `run` (agent) | `mistral/mistral-small-latest` |
 | `LLM_CONVERSATION_STORE` | Model for conversation topic/summary | FastAPI service | `mistral/mistral-small-latest` |
+| `LLM_CONVERSATION_STORE_TIMEOUT_SECONDS` | Per-attempt client-side deadline for the topic/summary call (2 attempts max) | Optional | `12` |
 | `LITELLM_PROXY_API_BASE` | LiteLLM Proxy URL | with `litellm_proxy/` models | *not set* |
 | `INTENT_DETECTION_TINY_MODEL` | HF id for the small intent model | `train` (optional) | `google/bert_uncased_L-4_H-128_A-2` |
 | `INTENT_DETECTION_LARGE_MODEL` | HF id for the large intent model | `train` (optional) | `distilbert-base-uncased` |

{fastworkflow-3.0.1 → fastworkflow-3.1.2}/README.md

@@ -572,6 +572,7 @@ Two files per workflow (templates ship with `fastworkflow examples fetch`).
 | `LLM_PLANNER` | Model for the agent's task planner | `run` (agent) | `mistral/mistral-small-latest` |
 | `LLM_AGENT` | Model for the DSPy agent | `run` (agent) | `mistral/mistral-small-latest` |
 | `LLM_CONVERSATION_STORE` | Model for conversation topic/summary | FastAPI service | `mistral/mistral-small-latest` |
+| `LLM_CONVERSATION_STORE_TIMEOUT_SECONDS` | Per-attempt client-side deadline for the topic/summary call (2 attempts max) | Optional | `12` |
 | `LITELLM_PROXY_API_BASE` | LiteLLM Proxy URL | with `litellm_proxy/` models | *not set* |
 | `INTENT_DETECTION_TINY_MODEL` | HF id for the small intent model | `train` (optional) | `google/bert_uncased_L-4_H-128_A-2` |
 | `INTENT_DETECTION_LARGE_MODEL` | HF id for the large intent model | `train` (optional) | `distilbert-base-uncased` |

{fastworkflow-3.0.1 → fastworkflow-3.1.2}/fastworkflow/_workflows/command_metadata_extraction/intent_detection.py

@@ -111,12 +111,29 @@ class CommandNamePrediction:
             command = command.replace(f"{tentative_command_name}", "").strip().replace("  ", " ")
         else:
             # Use Levenshtein distance for fuzzy matching with the full command part after @
+            # No match is ([], None), never (None, None) — len() here is safe.
             best_matched_commands, _ = find_best_matches(
                 command.replace(" ", "_"),
                 command_name_dict.keys(),
                 threshold=0.3  # Adjust threshold as needed
             )
-            if best_matched_commands:
+            if (
+                len(best_matched_commands) > 1
+                and nlu_pipeline_stage == NLUPipelineStage.INTENT_DETECTION
+            ):
+                # Commands sharing a prefix tie at distance 0, because scoring
+                # compares only the leading len(input) characters, and
+                # command_name_dict iterates a set — so picking [0] would choose
+                # nondeterministically between them across processes. Leave the
+                # name unset so the classifier and its ambiguity prompt decide.
+                # The clarification stages are deliberately excluded: they have
+                # no classifier to fall back to.
+                logger.warning(
+                    f"Fuzzy pre-match tied across {best_matched_commands} for "
+                    f"utterance '{command}' in context '{command_context_name}'. "
+                    "Deferring to the classifier instead of picking one."
+                )
+            elif best_matched_commands:
                 command_name = best_matched_commands[0]
 
         if nlu_pipeline_stage == NLUPipelineStage.INTENT_DETECTION:

{fastworkflow-3.0.1 → fastworkflow-3.1.2}/fastworkflow/docs/integrate-chat-agent/reference.md

@@ -168,7 +168,11 @@ class ResponseGenerator:
 ```
 - Use `default="NOT_FOUND"` for parameters so missing values are detected, not hallucinated.
 - Use `Field` `description` + `examples` (and `pattern`/`min_length` where helpful) to drive accurate parameter extraction.
-- Optional hooks: `db_lookup(workflow_snapshot, command)`, `process_extracted_parameters(...)`.
+- Optional hooks: `db_lookup(workflow, field_name, field_value) -> tuple[bool, str | None, list[str]]`,
+  `process_extracted_parameters(...)`. `db_lookup` runs for fields marked
+  `json_schema_extra={'db_lookup': True}` and has three return states: `(True, value, [])`
+  overwrites the field, `(False, None, [suggestions])` fails validation, and
+  `(False, None, [])` does neither — use that last one for a value your hook does not own.
 - For LLM-generated responses, use `fastworkflow.utils.dspy_utils.dspySignature(Signature.Input, Signature.Output)` with `dspy.Predict`.
 
 ### Context model — `_commands/context_inheritance_model.json`

{fastworkflow-3.0.1 → fastworkflow-3.1.2}/fastworkflow/examples/fastworkflow.env

@@ -9,6 +9,22 @@ LLM_PLANNER=mistral/mistral-small-latest
 LLM_AGENT=mistral/mistral-small-latest
 LLM_CONVERSATION_STORE=mistral/mistral-small-latest
 
+# Client-side deadline, in seconds, for ONE LLM_CONVERSATION_STORE attempt
+# (conversation topic/summary generation). Defaults to 12.
+#
+# This is a deadline on the request, not on whoever is awaiting it, and that is
+# the point: the call runs in a worker thread, and a timeout on the await would
+# cancel the wait while the thread kept running - which at process exit is
+# joined for up to 300 s. Bounding the request is what lets the thread end by
+# itself.
+#
+# The call gets at most two attempts (one retry), so the worst case is about
+# twice this value. Keep the product inside the server's 30 s shutdown drain, or
+# a rotate in flight when the process stops can outlive it. Do not set this at
+# or below the normal latency of a topic+summary generation (a few seconds):
+# every merely-slow /new_conversation then fails with HTTP 500.
+# LLM_CONVERSATION_STORE_TIMEOUT_SECONDS=12
+
 # ============================================================================
 # LiteLLM Proxy Configuration (Optional)
 # ============================================================================

{fastworkflow-3.0.1 → fastworkflow-3.1.2}/fastworkflow/run_fastapi_mcp/README.md

@@ -48,12 +48,22 @@ Configure in your environment (loaded at process startup via CLI args or env loa
 |----------|-------------|----------|---------|
 | `FASTWORKFLOW_STATE_ROOT` | Absolute root for all persistent state (conversations, suspended sessions, checkpoints) | No | `~/.local/state/fastworkflow` |
 | `FASTWORKFLOW_WORKFLOW_ID` | Overrides the per-workflow state namespace (defaults to the workflow folder name) | No | *workflow folder name* |
+| `LLM_CONVERSATION_STORE_TIMEOUT_SECONDS` | Per-attempt client-side deadline for the topic/summary call, in seconds. At most 2 attempts, so the wall-clock worst case is about twice this plus backoff — kept under the 30s shutdown drain on purpose | No | `12` |
 | `--expect_encrypted_jwt` | Enable full JWT signature verification (pass flag to require signed tokens) | No | False (no verification by default) |
 
+Set these in the workflow's `fastworkflow.env`, not as shell exports: values are read from the env files loaded at startup.
+
 Notes:
 - Conversation DBs are stored under `FASTWORKFLOW_STATE_ROOT/workflows/<workflow-id>/conversations` (directory is auto-created).
 - `/conversations` now accepts a `limit` query parameter (default `20`).
 - Shutdown waits up to 30 seconds for active turns (hard-coded).
+- Shutdown does **not** generate conversation topics or summaries. It makes any
+  unsaved turns durable and leaves the placeholder blank topic. A conversation is
+  labeled when it is used as a chat instead: on its first completed chat turn, on
+  `POST /activate_conversation` if still blank, and on `POST /new_conversation`.
+  Labels refresh as a thread grows, at turn counts 1, 4, 16, 64, … A blank `topic`
+  in `GET /conversations` means "no successful title yet" — a conversation that
+  only ever ran `/initialize` or `/perform_action` keeps it, by design.
 
 ## Auth Modes
 

{fastworkflow-3.0.1 → fastworkflow-3.1.2}/fastworkflow/run_fastapi_mcp/__main__.py

@@ -62,10 +62,13 @@ from .mcp_specific import setup_mcp
 from .utils import (
     get_channelconversations_dir,
     CHECKPOINT_REAP_INTERVAL_SECONDS,
+    SHUTDOWN_DRAIN_SECONDS,
     ChannelSessionManager,
     MAX_CONVERSATION_TURNS_IN_MEMORY,
+    ensure_topic_and_summary,
     save_conversation_incremental,
     save_last_turn_feedback,
+    try_ensure_topic_and_summary,
     InitializationRequest,
     TokenResponse,
     InitializeResponse,
@@ -105,6 +108,10 @@ from .conversation_store import (
     ConversationStore,
     ConversationSummary,
     generate_topic_and_summary,
+    resolve_topic_generation_timeout,
+    topic_generation_timeout_seconds,
+    TOPIC_GENERATION_MAX_RETRIES,
+    TOPIC_GENERATION_TIMEOUT_ENV_VAR,
     extract_turns_from_history,
     restore_history_from_turns
 )
@@ -360,6 +367,24 @@ async def lifespan(_app: FastAPI):
         resolved, source = session_manager.configure_max_live_sessions()
         logger.info(f"max_live_sessions={resolved} (source={source})")
 
+        # Same reasoning for the topic/summary deadline: resolved once here so a
+        # malformed value rejects startup instead of failing every rotate at
+        # runtime, and logged with its source so an operator can see whether
+        # their override was actually picked up.
+        timeout, timeout_source = resolve_topic_generation_timeout()
+        attempts = TOPIC_GENERATION_MAX_RETRIES + 1
+        logger.info(
+            f"{TOPIC_GENERATION_TIMEOUT_ENV_VAR}={timeout} "
+            f"(source={timeout_source}), attempts={attempts}"
+        )
+        if timeout * attempts >= SHUTDOWN_DRAIN_SECONDS:
+            logger.warning(
+                f"{TOPIC_GENERATION_TIMEOUT_ENV_VAR}={timeout} over {attempts} "
+                f"attempt(s) can exceed the {SHUTDOWN_DRAIN_SECONDS}s shutdown "
+                "drain, so a conversation rotate in flight when this process is "
+                "asked to stop may be killed part-way through"
+            )
+
         # Mark FastWorkflow as initialized for readiness probe
         readiness_state.set_initialized(True)
         
@@ -405,7 +430,28 @@ async def lifespan(_app: FastAPI):
         return remaining
 
     async def finalize_conversations_on_shutdown(skip_channel_ids: list[str]) -> None:
-        logger.info("Finalizing conversations with topic and summary...")
+        """Make each quiescent channel's unsaved turns durable. Never label them.
+
+        Shutdown generates no topics or summaries. That was one synchronous
+        LLM_CONVERSATION_STORE call per live channel, untimed and unbudgeted, in
+        front of the checkpoints stop_all_chat_sessions writes — so under a 30 s
+        termination grace period the process was killed part-way through
+        generating titles and lost everything each channel had accumulated since
+        its last eviction. Conversations are left with the blank placeholder
+        topic and summary the store already writes for them.
+
+        What is worth doing here is the durable save. A turn persists from inside
+        _run_turn's own try, so a turn whose work raised leaves in-memory history
+        that was never appended — including on a channel that never got as far as
+        reserving a conversation id. save_conversation_incremental is the same
+        chokepoint the turn path uses: it reserves that id when there is none,
+        appends only turns above the high-water mark, and creates the record with
+        the blank placeholders rather than inventing a topic to store.
+        """
+        logger.info(
+            "Persisting unsaved conversation turns at shutdown; conversations are "
+            "left with placeholder topic and summary (no topic generation)"
+        )
         skip = set(skip_channel_ids)
         for channel_id in list(session_manager._sessions.keys()):
             if channel_id in skip:
@@ -413,20 +459,17 @@ async def lifespan(_app: FastAPI):
             runtime = await session_manager.get_session(channel_id)
             if not runtime:
                 continue
-            if turns := _conversation_turns_for_summary(runtime):
-                try:
-                    topic, summary = generate_topic_and_summary(turns)
-                    if runtime.active_conversation_id > 0:
-                        runtime.conversation_store.update_conversation_topic_summary(
-                            runtime.active_conversation_id, topic, summary
-                        )
-                        logger.info(f"Finalized conversation {runtime.active_conversation_id} for user {channel_id} during shutdown")
-                    else:
-                        logger.warning(f"Conversation history exists but no active_conversation_id for user {channel_id} during shutdown")
-                        conv_id = runtime.conversation_store.save_conversation(topic, summary, turns)
-                        logger.info(f"Created conversation {conv_id} for user {channel_id} during shutdown")
-                except Exception as e:
-                    logger.error(f"Failed to finalize conversation for user {channel_id} during shutdown: {e}")
+            try:
+                if appended := save_conversation_incremental(
+                    runtime, extract_turns_from_history, logger
+                ):
+                    logger.info(
+                        f"Persisted {appended} unsaved turn(s) to conversation "
+                        f"{runtime.active_conversation_id} for user {channel_id} "
+                        "during shutdown"
+                    )
+            except Exception as e:
+                logger.error(f"Failed to finalize conversation for user {channel_id} during shutdown: {e}")
 
     async def reap_checkpoints_periodically() -> None:
         """Drive checkpoint and pending-state retention. Neither store has a timer.
@@ -537,7 +580,14 @@ async def lifespan(_app: FastAPI):
         reaper.cancel()
         with contextlib.suppress(asyncio.CancelledError):
             await reaper
-        still_busy = await wait_for_active_turns_to_complete(max_wait_seconds=30)
+        still_busy = await wait_for_active_turns_to_complete(
+            max_wait_seconds=SHUTDOWN_DRAIN_SECONDS
+        )
+        # Order between these two is no longer safety-critical: with topic
+        # generation gone both are bounded local SQLite writes, so neither can
+        # consume the termination grace period and leave the other unrun. It
+        # stays as it is because finalize reads the execution contexts that
+        # stop_all_chat_sessions closes.
         await finalize_conversations_on_shutdown(still_busy)
         await stop_all_chat_sessions(still_busy)
         logger.info("FastWorkflow FastAPI service shutdown complete")
@@ -1244,10 +1294,15 @@ async def invoke_agent_stream(
             return turn_output
 
         async def owned_turn(execn) -> None:
-            try:
-                await run_owned_turn(
-                    runtime, turn_registry, execn, streaming_work, session_manager
-                )
+            async def finish_stream() -> None:
+                """Deliver the terminal event, then end the body.
+
+                Handed to run_owned_turn as its on_done so the response completes
+                as soon as the turn does, instead of waiting on the post-turn
+                conversation labeling. The error event has to go out ahead of the
+                sentinel: the body's drain loop stops at the sentinel, so anything
+                emitted after it is never read.
+                """
                 if execn.error is not None:
                     await emit(
                         "error",
@@ -1258,7 +1313,23 @@ async def invoke_agent_stream(
                             )
                         },
                     )
+                await events.put(None)
+
+            try:
+                await run_owned_turn(
+                    runtime,
+                    turn_registry,
+                    execn,
+                    streaming_work,
+                    session_manager,
+                    on_done=finish_stream,
+                )
             finally:
+                # Kept as the guarantee, not the normal path: finish_stream has
+                # already ended the body. A second sentinel is harmless (the drain
+                # loop stopped at the first and never reads it), whereas a missing
+                # one - run_owned_turn raising before its finally, or finish_stream
+                # itself failing - would hang the client forever.
                 await events.put(None)
 
         try:
@@ -1497,8 +1568,15 @@ async def new_conversation(
 ) -> dict[str, str]:
     """
     Persist the current conversation and start a new one.
-    Generates topic and summary synchronously; on failure, does not rotate.
-    
+    Generates topic and summary off the event loop; on failure, does not rotate.
+
+    Rotate stays strict (fix-dzs.4). It is an explicit user action, and archiving
+    a thread the user can no longer find - /activate_conversation looks
+    conversations up by topic - is worse than telling them it did not happen.
+    What changes is that the failure is now prompt: the generation is bounded at
+    the LLM client, so this answers within that bound instead of hanging on an
+    unresponsive provider.
+
     Requires a valid JWT access token in the Authorization header (Bearer token format).
     """
     channel_id = session.channel_id
@@ -1513,20 +1591,86 @@ async def new_conversation(
             # Serialize ctx mutation with turns; reject if a turn is active (§3.4).
             _reject_if_busy(channel_id)
             async with runtime.lock:
+                # Persist before labeling (fix-dzs.9). A rotate clears the
+                # in-memory history, so anything not yet durable at that moment is
+                # gone - and a turn persists from inside _run_turn's own try, so a
+                # store failure there leaves history holding turns with no record
+                # and, if a previous rotate had already reserved an id, no way to
+                # write one. Labeling that state raised ValueError out of
+                # update_conversation_topic_summary AFTER paying for the
+                # generation, so the rotate that would have cleaned the state up
+                # was the one thing the user could not do. This is the same
+                # chokepoint shutdown uses: it reserves the id when there is none,
+                # appends only what is missing, and creates the record - which is
+                # what makes the label write below well-defined.
+                save_conversation_incremental(
+                    runtime, extract_turns_from_history, logger
+                )
+
                 # Summarize the whole conversation, not just the in-memory window
                 if turns := _conversation_turns_for_summary(runtime):
-                    # Generate topic and summary synchronously (turns already saved incrementally)
-                    topic, summary = generate_topic_and_summary(turns)
-
-                    # Update topic/summary for the conversation (turns already persisted)
+                    # Through the shared helper, so a rotate and a lazy fill
+                    # cannot both be generating for this channel at once and both
+                    # inherit the blank-topic policy. force=True because a rotate
+                    # is an explicit user action: it labels whether or not the
+                    # refresh schedule says the label is due, and the turns are
+                    # passed in because this call site is the only one that can
+                    # summarize a conversation with no durable record yet.
+                    #
+                    # The generation happens in a worker thread inside the helper.
+                    # DSPy is synchronous, so calling it here stalled the whole
+                    # event loop - every other channel's request included - for
+                    # the length of an LLM round trip. There is deliberately no
+                    # asyncio.wait_for around it; see the helper's docstring.
+                    #
+                    # Still inside runtime.lock: this serializes conversation-state
+                    # mutation, and the rotate below depends on it.
+                    try:
+                        topic, summary = await ensure_topic_and_summary(
+                            runtime,
+                            generate_topic_and_summary,
+                            turns=turns,
+                            force=True,
+                        )
+                    except Exception as e:
+                        # "Labeling", not "generation": this covers the generation
+                        # AND the write that follows it, and saying the wrong one
+                        # sends an operator to the wrong place. The turns really are
+                        # safe here - the incremental save above ran before any of
+                        # this - so that half of the message is now a fact rather
+                        # than a hope.
+                        logger.error(
+                            f"Could not label the conversation for session {channel_id}, "
+                            f"not rotating: {type(e).__name__}: {e}"
+                        )
+                        raise HTTPException(
+                            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                            detail=(
+                                f"Could not label the conversation for channel_id: "
+                                f"{channel_id}; it was NOT rotated. Its turns are "
+                                f"durably recorded. Generation is given "
+                                f"{TOPIC_GENERATION_MAX_RETRIES + 1} attempt(s) of "
+                                f"{TOPIC_GENERATION_TIMEOUT_ENV_VAR}="
+                                f"{topic_generation_timeout_seconds()}s each "
+                                f"(LLM_CONVERSATION_STORE). "
+                                f"Cause: {type(e).__name__}: {e}"
+                            ),
+                        ) from e
+
+                    # Topic/summary written by the helper above for the
+                    # conversation (turns already persisted)
                     if runtime.active_conversation_id > 0:
                         conv_id = runtime.active_conversation_id
-                        runtime.conversation_store.update_conversation_topic_summary(
-                            conv_id, topic, summary
-                        )
                         logger.info(f"Finalized conversation {conv_id} with topic and summary for session {channel_id}")
                     else:
-                        # Edge case: conversation history exists but no active ID (shouldn't happen with incremental saves)
+                        # Unreachable since the incremental save moved above this
+                        # (fix-dzs.9), and kept only as a belt-and-braces: reaching
+                        # `turns` non-empty requires either in-memory turns, in
+                        # which case that save reserved an id and wrote a record, or
+                        # a durable record, which needs an id already. Left in place
+                        # rather than deleted because it is the one branch that
+                        # would still persist turns if that reasoning is ever
+                        # invalidated, and the cost of keeping it is a log line.
                         logger.warning(f"Conversation history exists but no active_conversation_id for session {channel_id}")
                         conv_id = runtime.conversation_store.save_conversation(topic, summary, turns)
                         logger.info(f"Created conversation {conv_id} for session {channel_id}")
@@ -1681,7 +1825,18 @@ async def activate_conversation(
 ) -> dict[str, str]:
     """
     Activate a conversation by its conversation_id.
-    
+
+    A conversation that is still unlabeled is labeled here, from its stored turns.
+    This is the trigger that covers a conversation whose turns were recorded by a
+    process that died before labeling anything: opening it is the moment a title
+    becomes useful, since /activate_conversation is also how conversations are
+    looked up by topic. A conversation that already has a title is not
+    relabeled - that would spend an LLM call to re-describe the same turns.
+
+    Labeling never fails the activation: on a generation failure the conversation
+    is activated anyway and keeps its blank topic, which is the sentinel that
+    makes the next eligible trigger retry.
+
     Requires a valid JWT access token in the Authorization header (Bearer token format).
     """
     channel_id = session.channel_id
@@ -1693,8 +1848,11 @@ async def activate_conversation(
                     detail=f"User session not found: {channel_id}"
                 )
 
-            # Get conversation by ID
-            conv = runtime.conversation_store.get_conversation(request.conversation_id)
+            # Get conversation by ID, carrying only the window that is about to be
+            # restored: the rest of it would be deserialized and then dropped.
+            conv = runtime.conversation_store.get_conversation_window(
+                request.conversation_id, MAX_CONVERSATION_TURNS_IN_MEMORY
+            )
             if not conv:
                 raise HTTPException(
                     status_code=status.HTTP_404_NOT_FOUND,
@@ -1709,14 +1867,24 @@ async def activate_conversation(
                 # Restore the newest window of the conversation; the rest stays in
                 # the durable record. Everything restored is already recorded, so
                 # the high-water mark moves with it and the next incremental save
-                # does not append the conversation a second time.
-                restored_history = restore_history_from_turns(
-                    conv["turns"][-MAX_CONVERSATION_TURNS_IN_MEMORY:]
-                )
+                # does not append the conversation a second time. The window came
+                # from the read above, so there is nothing left to slice here.
+                restored_history = restore_history_from_turns(conv["turns"])
                 runtime.execution_context._conversation_history = restored_history
                 runtime.durable_turn_count = len(restored_history.messages)
                 logger.info(f"Activated conversation {request.conversation_id} for session {channel_id}")
 
+                # After the activation, so the helper labels the conversation the
+                # user just opened, and inside runtime.lock for the same reason
+                # the rotate is: this serializes conversation-state mutation. The
+                # helper reads the whole durable conversation itself rather than
+                # reusing `conv` above, which now carries only the newest window -
+                # summarizing a window would silently produce "topic of the last
+                # N turns".
+                await try_ensure_topic_and_summary(
+                    runtime, generate_topic_and_summary
+                )
+
                 return {"status": "ok"}
 
     except HTTPException: