npm - flowent - Versions diffs - 0.2.0 → 0.2.1 - Mend

flowent 0.2.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/backend/src/flowent/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Flowent</title>
     <meta name="description" content="Flowent application" />
-    <script type="module" crossorigin src="/assets/index-BlaCigkZ.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CRvbsH4K.css">
+    <script type="module" crossorigin src="/assets/index-DUYj6rgD.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CRSV2xu1.css">
   </head>
   <body>
     <div id="root"></div>

package/backend/src/flowent/storage.py CHANGED Viewed

@@ -7,6 +7,7 @@ from pydantic import BaseModel, ConfigDict, Field
 from flowent.llm import ChatMessage, ProviderFormat, ReasoningEffort
 from flowent.paths import data_directory
+from flowent.usage import TokenUsageInfo
 class StoredTelegramSession(BaseModel):
@@ -172,6 +173,9 @@ class StoredMessage(BaseModel):
     )
     thinking: str = Field(default="", exclude_if=lambda value: value == "")
     tools: list[StoredToolItem] = Field(default_factory=list)
+    usage_info: TokenUsageInfo | None = Field(
+        default=None, exclude_if=lambda value: value is None
+    )
 class StoredCompactionCheckpoint(BaseModel):
@@ -193,12 +197,16 @@ class StoredState(BaseModel):
     active_run_event_index: int = 0
     active_run_id: str | None = None
+    is_compacting: bool = False
     mcp_servers: list[StoredMcpServer]
     messages: list[StoredMessage]
     providers: list[StoredProvider]
     settings: StoredSettings
     skills: list[StoredSkill]
     telegram_bot: StoredTelegramBot
+    usage_info: TokenUsageInfo | None = Field(
+        default=None, exclude_if=lambda value: value is None
+    )
     writable_paths: list[StoredWritablePath] = Field(default_factory=list)
@@ -261,18 +269,34 @@ class StateStore:
                         StoredToolItem.model_validate(tool)
                         for tool in json.loads(row["tools"] or "[]")
                     ],
+                    usage_info=TokenUsageInfo.model_validate_json(row["usage_info"])
+                    if row["usage_info"]
+                    else None,
                 )
                 for row in connection.execute(
                     """
-                    SELECT id, author, content, tools, thinking, groups, status
+                    SELECT id, author, content, tools, thinking, groups, status, usage_info
                     FROM messages
                     ORDER BY position, id
                     """
                 )
             ]
+            usage_row = connection.execute(
+                """
+                SELECT is_compacting, usage_info
+                FROM workspace_context
+                WHERE id = 1
+                """
+            ).fetchone()
+            usage_info = (
+                TokenUsageInfo.model_validate_json(usage_row["usage_info"])
+                if usage_row and usage_row["usage_info"]
+                else None
+            )
         return StoredState(
             mcp_servers=mcp_servers,
+            is_compacting=bool(usage_row["is_compacting"]) if usage_row else False,
             messages=messages,
             providers=providers,
             settings=StoredSettings(
@@ -287,6 +311,7 @@ class StateStore:
             ),
             skills=[],
             telegram_bot=telegram_bot,
+            usage_info=usage_info,
             writable_paths=writable_paths,
         )
@@ -600,6 +625,26 @@ class StateStore:
     def save_messages(self, messages: list[StoredMessage]) -> list[StoredMessage]:
         with self.connect() as connection:
             connection.execute("DELETE FROM messages")
+            if messages:
+                latest_usage_info = next(
+                    (
+                        message.usage_info
+                        for message in reversed(messages)
+                        if message.usage_info is not None
+                    ),
+                    None,
+                )
+                if latest_usage_info is not None:
+                    connection.execute(
+                        """
+                        INSERT INTO workspace_context (id, usage_info)
+                        VALUES (1, ?)
+                        ON CONFLICT(id) DO UPDATE SET
+                            usage_info = excluded.usage_info,
+                            updated_at = unixepoch()
+                        """,
+                        (latest_usage_info.model_dump_json(),),
+                    )
             connection.executemany(
                 """
                 INSERT INTO messages (
@@ -610,9 +655,10 @@ class StateStore:
                     thinking,
                     groups,
                     status,
+                    usage_info,
                     position
                 )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 [
                     (
@@ -634,6 +680,9 @@ class StateStore:
                             ensure_ascii=False,
                         ),
                         message.status,
+                        message.usage_info.model_dump_json()
+                        if message.usage_info
+                        else None,
                         position,
                     )
                     for position, message in enumerate(messages)
@@ -665,9 +714,10 @@ class StateStore:
                     thinking,
                     groups,
                     status,
+                    usage_info,
                     position
                 )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(id) DO UPDATE SET
                     author = excluded.author,
                     content = excluded.content,
@@ -675,6 +725,7 @@ class StateStore:
                     thinking = excluded.thinking,
                     groups = excluded.groups,
                     status = excluded.status,
+                    usage_info = excluded.usage_info,
                     position = excluded.position
                 """,
                 (
@@ -693,11 +744,52 @@ class StateStore:
                         ensure_ascii=False,
                     ),
                     message.status,
+                    message.usage_info.model_dump_json()
+                    if message.usage_info
+                    else None,
                     position,
                 ),
             )
+            if message.usage_info is not None:
+                connection.execute(
+                    """
+                    INSERT INTO workspace_context (id, usage_info)
+                    VALUES (1, ?)
+                    ON CONFLICT(id) DO UPDATE SET
+                        usage_info = excluded.usage_info,
+                        updated_at = unixepoch()
+                    """,
+                    (message.usage_info.model_dump_json(),),
+                )
         return message
+    def read_usage_info(self) -> TokenUsageInfo | None:
+        with self.connect() as connection:
+            row = connection.execute(
+                """
+                SELECT usage_info
+                FROM workspace_context
+                WHERE id = 1
+                """
+            ).fetchone()
+        if row is None or not row["usage_info"]:
+            return None
+        return TokenUsageInfo.model_validate_json(row["usage_info"])
+    def save_usage_info(self, usage_info: TokenUsageInfo) -> TokenUsageInfo:
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO workspace_context (id, usage_info)
+                VALUES (1, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                    usage_info = excluded.usage_info,
+                    updated_at = unixepoch()
+                """,
+                (usage_info.model_dump_json(),),
+            )
+        return usage_info
     def read_compacted_context(self) -> str:
         with self.connect() as connection:
             row = connection.execute(
@@ -718,12 +810,38 @@ class StateStore:
                 ON CONFLICT(id) DO UPDATE SET
                     compacted_summary = excluded.compacted_summary,
                     active_compaction_id = NULL,
+                    usage_info = NULL,
                     updated_at = unixepoch()
                 """,
                 (summary,),
             )
         return summary
+    def read_is_compacting(self) -> bool:
+        with self.connect() as connection:
+            row = connection.execute(
+                """
+                SELECT is_compacting
+                FROM workspace_context
+                WHERE id = 1
+                """
+            ).fetchone()
+        return bool(row["is_compacting"]) if row else False
+    def save_is_compacting(self, is_compacting: bool) -> bool:
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO workspace_context (id, is_compacting)
+                VALUES (1, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                    is_compacting = excluded.is_compacting,
+                    updated_at = unixepoch()
+                """,
+                (int(is_compacting),),
+            )
+        return is_compacting
     def read_active_compaction_checkpoint(
         self,
     ) -> StoredCompactionCheckpoint | None:
@@ -1020,6 +1138,7 @@ class StateStore:
                 author TEXT NOT NULL,
                 content TEXT NOT NULL,
                 status TEXT NOT NULL DEFAULT 'completed',
+                usage_info TEXT,
                 position INTEGER NOT NULL
             );
@@ -1027,6 +1146,8 @@ class StateStore:
                 id INTEGER PRIMARY KEY CHECK (id = 1),
                 compacted_summary TEXT NOT NULL DEFAULT '',
                 active_compaction_id TEXT,
+                is_compacting INTEGER NOT NULL DEFAULT 0,
+                usage_info TEXT,
                 updated_at INTEGER NOT NULL DEFAULT (unixepoch())
             );
@@ -1089,6 +1210,8 @@ class StateStore:
             connection.execute(
                 "ALTER TABLE messages ADD COLUMN groups TEXT NOT NULL DEFAULT '[]'"
             )
+        if "usage_info" not in columns:
+            connection.execute("ALTER TABLE messages ADD COLUMN usage_info TEXT")
         settings_columns = {
             row["name"] for row in connection.execute("PRAGMA table_info(settings)")
         }
@@ -1109,3 +1232,12 @@ class StateStore:
             connection.execute(
                 "ALTER TABLE workspace_context ADD COLUMN active_compaction_id TEXT"
             )
+        if "usage_info" not in workspace_context_columns:
+            connection.execute(
+                "ALTER TABLE workspace_context ADD COLUMN usage_info TEXT"
+            )
+        if "is_compacting" not in workspace_context_columns:
+            connection.execute(
+                "ALTER TABLE workspace_context "
+                "ADD COLUMN is_compacting INTEGER NOT NULL DEFAULT 0"
+            )

package/backend/src/flowent/usage.py ADDED Viewed

@@ -0,0 +1,315 @@
+import json
+from collections.abc import Mapping, Sequence
+from typing import Any
+from pydantic import BaseModel, ConfigDict, Field
+DEFAULT_MODEL_CONTEXT_WINDOW = 120_000
+MODEL_CONTEXT_WINDOWS: dict[str, int] = {
+    "claude-3-7-sonnet-20250219": 200_000,
+    "claude-3-haiku-20240307": 200_000,
+    "claude-3-opus-20240229": 200_000,
+    "claude-4-opus-20250514": 200_000,
+    "claude-4-sonnet-20250514": 1_000_000,
+    "claude-haiku-4-5": 200_000,
+    "claude-haiku-4-5-20251001": 200_000,
+    "claude-opus-4-1": 200_000,
+    "claude-opus-4-1-20250805": 200_000,
+    "claude-opus-4-20250514": 200_000,
+    "claude-opus-4-5": 200_000,
+    "claude-opus-4-5-20251101": 200_000,
+    "claude-opus-4-6": 1_000_000,
+    "claude-opus-4-6-20260205": 1_000_000,
+    "claude-opus-4-7": 1_000_000,
+    "claude-opus-4-7-20260416": 1_000_000,
+    "claude-opus-4-8": 1_000_000,
+    "claude-sonnet-4-20250514": 1_000_000,
+    "claude-sonnet-4-5": 200_000,
+    "claude-sonnet-4-5-20250929": 200_000,
+    "claude-sonnet-4-5-20250929-v1:0": 200_000,
+    "claude-sonnet-4-6": 1_000_000,
+    "gemini-2.5-computer-use-preview-10-2025": 128_000,
+    "gemini-2.5-flash": 1_048_576,
+    "gemini-2.5-flash-image": 32_768,
+    "gemini-2.5-flash-lite": 1_048_576,
+    "gemini-2.5-flash-lite-preview-06-17": 1_048_576,
+    "gemini-2.5-flash-lite-preview-09-2025": 1_048_576,
+    "gemini-2.5-flash-native-audio-latest": 1_048_576,
+    "gemini-2.5-flash-native-audio-preview-09-2025": 1_048_576,
+    "gemini-2.5-flash-native-audio-preview-12-2025": 1_048_576,
+    "gemini-2.5-flash-preview-09-2025": 1_048_576,
+    "gemini-2.5-pro": 1_048_576,
+    "gemini-2.5-pro-preview-tts": 1_048_576,
+    "gemini-3-flash-preview": 1_048_576,
+    "gemini-3-pro-image-preview": 65_536,
+    "gemini-3-pro-preview": 1_048_576,
+    "gemini-3.1-flash-image-preview": 65_536,
+    "gemini-3.1-flash-lite": 1_048_576,
+    "gemini-3.1-flash-lite-preview": 1_048_576,
+    "gemini-3.1-flash-live-preview": 131_072,
+    "gemini-3.1-pro-preview": 1_048_576,
+    "gemini-3.1-pro-preview-customtools": 1_048_576,
+    "gemini-3.5-flash": 1_048_576,
+    "gpt-4.1": 1_047_576,
+    "gpt-4.1-2025-04-14": 1_047_576,
+    "gpt-4.1-mini": 1_047_576,
+    "gpt-4.1-mini-2025-04-14": 1_047_576,
+    "gpt-4.1-nano": 1_047_576,
+    "gpt-4.1-nano-2025-04-14": 1_047_576,
+    "gpt-5": 272_000,
+    "gpt-5-2025-08-07": 272_000,
+    "gpt-5-chat": 128_000,
+    "gpt-5-chat-latest": 128_000,
+    "gpt-5-codex": 272_000,
+    "gpt-5-mini": 272_000,
+    "gpt-5-mini-2025-08-07": 272_000,
+    "gpt-5-nano": 272_000,
+    "gpt-5-nano-2025-08-07": 272_000,
+    "gpt-5-pro": 128_000,
+    "gpt-5-pro-2025-10-06": 128_000,
+    "gpt-5-search-api": 272_000,
+    "gpt-5-search-api-2025-10-14": 272_000,
+    "gpt-5.1": 272_000,
+    "gpt-5.1-2025-11-13": 272_000,
+    "gpt-5.1-chat-latest": 128_000,
+    "gpt-5.1-codex": 272_000,
+    "gpt-5.1-codex-max": 272_000,
+    "gpt-5.1-codex-mini": 272_000,
+    "gpt-5.2": 272_000,
+    "gpt-5.2-2025-12-11": 272_000,
+    "gpt-5.2-chat-latest": 128_000,
+    "gpt-5.2-codex": 272_000,
+    "gpt-5.2-pro": 272_000,
+    "gpt-5.2-pro-2025-12-11": 272_000,
+    "gpt-5.3-chat-latest": 128_000,
+    "gpt-5.3-codex": 272_000,
+    "gpt-5.4": 1_050_000,
+    "gpt-5.4-2026-03-05": 1_050_000,
+    "gpt-5.4-mini": 272_000,
+    "gpt-5.4-mini-2026-03-17": 272_000,
+    "gpt-5.4-nano": 272_000,
+    "gpt-5.4-nano-2026-03-17": 272_000,
+    "gpt-5.4-pro": 1_050_000,
+    "gpt-5.4-pro-2026-03-05": 1_050_000,
+    "gpt-5.5": 1_050_000,
+    "gpt-5.5-2026-04-23": 1_050_000,
+    "gpt-5.5-pro": 1_050_000,
+    "gpt-5.5-pro-2026-04-23": 1_050_000,
+    "o3": 200_000,
+    "o3-2025-04-16": 200_000,
+    "o3-deep-research": 200_000,
+    "o3-deep-research-2025-06-26": 200_000,
+    "o3-mini": 200_000,
+    "o3-mini-2025-01-31": 200_000,
+    "o3-pro": 200_000,
+    "o3-pro-2025-06-10": 200_000,
+    "o4-mini": 200_000,
+    "o4-mini-2025-04-16": 200_000,
+    "o4-mini-deep-research": 200_000,
+    "o4-mini-deep-research-2025-06-26": 200_000,
+}
+MODEL_CONTEXT_WINDOW_NAMES = tuple(sorted(MODEL_CONTEXT_WINDOWS, key=len, reverse=True))
+class TokenUsage(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    input_tokens: int = 0
+    cached_input_tokens: int = 0
+    output_tokens: int = 0
+    reasoning_output_tokens: int = 0
+    total_tokens: int = 0
+    def add(self, other: "TokenUsage") -> "TokenUsage":
+        return TokenUsage(
+            input_tokens=self.input_tokens + other.input_tokens,
+            cached_input_tokens=self.cached_input_tokens + other.cached_input_tokens,
+            output_tokens=self.output_tokens + other.output_tokens,
+            reasoning_output_tokens=self.reasoning_output_tokens
+            + other.reasoning_output_tokens,
+            total_tokens=self.total_tokens + other.total_tokens,
+        )
+class TokenUsageInfo(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    total_token_usage: TokenUsage = Field(default_factory=TokenUsage)
+    last_token_usage: TokenUsage = Field(default_factory=TokenUsage)
+    model_context_window: int | None = None
+def current_model_context_window(model_name: str | None = None) -> int:
+    return model_context_window_for(model_name)
+def model_context_window_for(model_name: str | None = None) -> int:
+    candidates = normalized_model_name_candidates(model_name)
+    for candidate in candidates:
+        context_window = MODEL_CONTEXT_WINDOWS.get(candidate)
+        if context_window is not None:
+            return context_window
+    for candidate in candidates:
+        for known_model in MODEL_CONTEXT_WINDOW_NAMES:
+            if is_model_context_window_prefix_match(candidate, known_model):
+                return MODEL_CONTEXT_WINDOWS[known_model]
+    return DEFAULT_MODEL_CONTEXT_WINDOW
+def normalized_model_name_candidates(model_name: str | None) -> tuple[str, ...]:
+    if model_name is None:
+        return ()
+    normalized = model_name.strip().lower()
+    if not normalized:
+        return ()
+    candidates = [normalized]
+    if "/" in normalized:
+        candidates.append(normalized.rsplit("/", 1)[-1])
+    return tuple(dict.fromkeys(candidates))
+def is_model_context_window_prefix_match(candidate: str, known_model: str) -> bool:
+    if candidate == known_model:
+        return True
+    if not candidate.startswith(known_model):
+        return False
+    return candidate[len(known_model)] in {"-", ".", ":", "/"}
+def append_token_usage(
+    usage_info: TokenUsageInfo | None,
+    usage: TokenUsage,
+    *,
+    model_context_window: int | None = None,
+) -> TokenUsageInfo:
+    info = usage_info or TokenUsageInfo(model_context_window=model_context_window)
+    return TokenUsageInfo(
+        total_token_usage=info.total_token_usage.add(usage),
+        last_token_usage=usage,
+        model_context_window=model_context_window or info.model_context_window,
+    )
+def recompute_context_usage(
+    usage_info: TokenUsageInfo | None,
+    active_context_tokens: int,
+    *,
+    model_context_window: int | None = None,
+) -> TokenUsageInfo:
+    info = usage_info or TokenUsageInfo(model_context_window=model_context_window)
+    return TokenUsageInfo(
+        total_token_usage=info.total_token_usage,
+        last_token_usage=TokenUsage(total_tokens=max(0, active_context_tokens)),
+        model_context_window=model_context_window or info.model_context_window,
+    )
+def token_usage_from_response(response: Any) -> TokenUsage | None:
+    usage = value_at(response, "usage")
+    if usage is None:
+        return None
+    input_tokens = first_int_value(
+        value_at(usage, "input_tokens"),
+        value_at(usage, "prompt_tokens"),
+    )
+    output_tokens = first_int_value(
+        value_at(usage, "output_tokens"),
+        value_at(usage, "completion_tokens"),
+    )
+    total_tokens = first_int_value(value_at(usage, "total_tokens"))
+    cached_input_tokens = first_int_value(
+        value_at(usage, "cached_input_tokens"),
+        value_at(usage, "cache_read_input_tokens"),
+        value_at(usage, "cached_tokens"),
+        nested_value_at(usage, "prompt_tokens_details", "cached_tokens"),
+        nested_value_at(usage, "input_tokens_details", "cached_tokens"),
+        nested_value_at(usage, "cache_read", "input_tokens"),
+    )
+    reasoning_output_tokens = first_int_value(
+        value_at(usage, "reasoning_output_tokens"),
+        nested_value_at(usage, "completion_tokens_details", "reasoning_tokens"),
+        nested_value_at(usage, "output_tokens_details", "reasoning_tokens"),
+    )
+    if total_tokens is None:
+        total_tokens = (input_tokens or 0) + (output_tokens or 0)
+    return TokenUsage(
+        input_tokens=input_tokens or 0,
+        cached_input_tokens=cached_input_tokens or 0,
+        output_tokens=output_tokens or 0,
+        reasoning_output_tokens=reasoning_output_tokens or 0,
+        total_tokens=total_tokens,
+    )
+def estimated_token_usage_for_messages(
+    messages: Sequence[Mapping[str, object]],
+    *,
+    output_content: str = "",
+) -> TokenUsage:
+    total_tokens = sum(estimate_mapping_message_tokens(message) for message in messages)
+    output_tokens = approximate_token_count(output_content)
+    return TokenUsage(
+        input_tokens=max(total_tokens - output_tokens, 0),
+        output_tokens=output_tokens,
+        total_tokens=total_tokens,
+    )
+def estimate_mapping_message_tokens(message: Mapping[str, object]) -> int:
+    total = approximate_token_count(string_content(message.get("content")))
+    tool_calls = message.get("tool_calls")
+    if tool_calls:
+        total += approximate_token_count(json.dumps(tool_calls, ensure_ascii=False))
+    if message.get("role") == "tool":
+        total += approximate_token_count(string_content(message.get("tool_call_id")))
+    return total
+def approximate_token_count(content: str) -> int:
+    if not content:
+        return 0
+    return max(1, (len(content) + 3) // 4)
+def string_content(value: object) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False)
+def value_at(value: Any, key: str, default: Any = None) -> Any:
+    if isinstance(value, Mapping):
+        return value.get(key, default)
+    return getattr(value, key, default)
+def nested_value_at(value: Any, *keys: str) -> Any:
+    current = value
+    for key in keys:
+        current = value_at(current, key)
+        if current is None:
+            return None
+    return current
+def first_int_value(*values: Any) -> int | None:
+    for value in values:
+        if isinstance(value, bool) or value is None:
+            continue
+        if isinstance(value, int):
+            return max(0, value)
+        if isinstance(value, float):
+            return max(0, int(value))
+        if isinstance(value, str):
+            try:
+                return max(0, int(value))
+            except ValueError:
+                continue
+    return None