typeagent-py 0.1.0__py3-none-any.whl

typeagent/storage/sqlite/schema.py

@@ -0,0 +1,248 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""SQLite database schema definitions."""
+
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+import typing
+import numpy as np
+
+from ...aitools.embeddings import NormalizedEmbedding
+
+# Constants
+CONVERSATION_SCHEMA_VERSION = "0.1"
+
+MESSAGES_SCHEMA = """
+CREATE TABLE IF NOT EXISTS Messages (
+    msg_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    -- Messages can store chunks directly in JSON or reference external storage via URI
+    chunks JSON NULL,             -- JSON array of text chunks, or NULL if using chunk_uri
+    chunk_uri TEXT NULL,          -- URI for external chunk storage, or NULL if using chunks
+    start_timestamp TEXT NULL,    -- ISO format with Z timezone
+    tags JSON NULL,               -- JSON array of tags
+    metadata JSON NULL,           -- Message metadata (source, dest, etc.)
+    extra JSON NULL,              -- Extra message fields that were serialized
+
+    CONSTRAINT chunks_xor_chunkuri CHECK (
+        (chunks IS NOT NULL AND chunk_uri IS NULL) OR
+        (chunks IS NULL AND chunk_uri IS NOT NULL)
+    )
+);
+"""
+
+TIMESTAMP_INDEX_SCHEMA = """
+CREATE INDEX IF NOT EXISTS idx_messages_start_timestamp ON Messages(start_timestamp);
+"""
+
+# Conversation metadata table (single row)
+CONVERSATION_METADATA_SCHEMA = """
+CREATE TABLE IF NOT EXISTS ConversationMetadata (
+    name_tag TEXT NOT NULL,           -- User-defined name for this conversation
+    schema_version TEXT NOT NULL,     -- Version of the metadata schema
+    created_at TEXT NOT NULL,         -- UTC timestamp when conversation was created
+    updated_at TEXT NOT NULL,         -- UTC timestamp when metadata was last updated
+    tags JSON NOT NULL,               -- JSON array of string tags
+    extra JSON NOT NULL               -- JSON object for additional metadata
+);
+"""
+
+SEMANTIC_REFS_SCHEMA = """
+CREATE TABLE IF NOT EXISTS SemanticRefs (
+    semref_id INTEGER PRIMARY KEY,
+    range_json JSON NOT NULL,          -- JSON of the TextRange object
+    knowledge_type TEXT NOT NULL,      -- Required to distinguish JSON types (entity, topic, etc.)
+    knowledge_json JSON NOT NULL       -- JSON of the Knowledge object
+);
+"""
+
+SEMANTIC_REF_INDEX_SCHEMA = """
+CREATE TABLE IF NOT EXISTS SemanticRefIndex (
+    term TEXT NOT NULL,             -- lowercased, not-unique/normalized
+    semref_id INTEGER NOT NULL,
+
+    FOREIGN KEY (semref_id) REFERENCES SemanticRefs(semref_id) ON DELETE CASCADE
+);
+"""
+
+SEMANTIC_REF_INDEX_TERM_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_semantic_ref_index_term ON SemanticRefIndex(term);
+"""
+
+MESSAGE_TEXT_INDEX_SCHEMA = """
+CREATE TABLE IF NOT EXISTS MessageTextIndex (
+    msg_id INTEGER NOT NULL,
+    chunk_ordinal INTEGER NOT NULL,
+    embedding BLOB NOT NULL,        -- Serialized embedding (numpy array as bytes)
+    index_position INTEGER,         -- Position in VectorBase index for fast lookup
+
+    PRIMARY KEY (msg_id, chunk_ordinal),
+    FOREIGN KEY (msg_id) REFERENCES Messages(msg_id) ON DELETE CASCADE
+);
+"""
+
+MESSAGE_TEXT_INDEX_MESSAGE_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_message_text_index_message ON MessageTextIndex(msg_id, chunk_ordinal);
+"""
+
+MESSAGE_TEXT_INDEX_POSITION_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_message_text_index_position ON MessageTextIndex(index_position);
+"""
+
+PROPERTY_INDEX_SCHEMA = """
+CREATE TABLE IF NOT EXISTS PropertyIndex (
+    prop_name TEXT NOT NULL,
+    value_str TEXT NOT NULL,
+    score REAL NOT NULL DEFAULT 1.0,
+    semref_id INTEGER NOT NULL,
+
+    FOREIGN KEY (semref_id) REFERENCES SemanticRefs(semref_id) ON DELETE CASCADE
+);
+"""
+
+PROPERTY_INDEX_PROP_NAME_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_property_index_prop_name ON PropertyIndex(prop_name);
+"""
+
+PROPERTY_INDEX_VALUE_STR_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_property_index_value_str ON PropertyIndex(value_str);
+"""
+
+PROPERTY_INDEX_COMBINED_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_property_index_combined ON PropertyIndex(prop_name, value_str);
+"""
+
+RELATED_TERMS_ALIASES_SCHEMA = """
+CREATE TABLE IF NOT EXISTS RelatedTermsAliases (
+    term TEXT NOT NULL,
+    alias TEXT NOT NULL,
+
+    PRIMARY KEY (term, alias)
+);
+"""
+
+RELATED_TERMS_ALIASES_TERM_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_related_aliases_term ON RelatedTermsAliases(term);
+"""
+
+RELATED_TERMS_ALIASES_ALIAS_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_related_aliases_alias ON RelatedTermsAliases(alias);
+"""
+
+RELATED_TERMS_FUZZY_SCHEMA = """
+CREATE TABLE IF NOT EXISTS RelatedTermsFuzzy (
+    term TEXT NOT NULL PRIMARY KEY,
+    term_embedding BLOB NOT NULL    -- Serialized embedding for the term
+);
+"""
+
+RELATED_TERMS_FUZZY_TERM_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_related_fuzzy_term ON RelatedTermsFuzzy(term);
+"""
+
+# Type aliases for database row tuples
+type ShreddedMessage = tuple[
+    str | None, str | None, str | None, str | None, str | None, str | None
+]
+type ShreddedSemanticRef = tuple[int, str, str, str]
+
+type ShreddedMessageText = tuple[int, int, str, bytes | None]
+type ShreddedPropertyIndex = tuple[str, str, float, int]
+type ShreddedRelatedTermsAlias = tuple[str, str]
+type ShreddedRelatedTermsFuzzy = tuple[str, float, bytes]
+
+
+@dataclass
+class ConversationMetadata:
+    """Metadata for the current conversation stored in SQLite."""
+
+    name_tag: str
+    schema_version: str
+    created_at: datetime
+    updated_at: datetime
+    tags: list[str]
+    extra: dict[str, typing.Any]
+
+
+@typing.overload
+def serialize_embedding(embedding: NormalizedEmbedding) -> bytes: ...
+
+
+@typing.overload
+def serialize_embedding(embedding: None) -> None: ...
+
+
+def serialize_embedding(embedding: NormalizedEmbedding | None) -> bytes | None:
+    """Serialize a numpy embedding array to bytes for SQLite storage."""
+    if embedding is None:
+        return None
+    return embedding.tobytes()
+
+
+@typing.overload
+def deserialize_embedding(blob: bytes) -> NormalizedEmbedding: ...
+
+
+@typing.overload
+def deserialize_embedding(blob: None) -> None: ...
+
+
+def deserialize_embedding(blob: bytes | None) -> NormalizedEmbedding | None:
+    """Deserialize bytes back to numpy embedding array."""
+    if blob is None:
+        return None
+    return np.frombuffer(blob, dtype=np.float32)
+
+
+def _create_default_metadata() -> ConversationMetadata:
+    """Create default conversation metadata."""
+    current_time = datetime.now(timezone.utc)
+    return ConversationMetadata(
+        name_tag="",
+        schema_version=CONVERSATION_SCHEMA_VERSION,
+        tags=[],
+        extra={},
+        created_at=current_time,
+        updated_at=current_time,
+    )
+
+
+def init_db_schema(db: sqlite3.Connection) -> None:
+    """Initialize the database schema with all required tables."""
+    cursor = db.cursor()
+
+    # Create all tables
+    cursor.execute(CONVERSATION_METADATA_SCHEMA)
+    cursor.execute(MESSAGES_SCHEMA)
+    cursor.execute(SEMANTIC_REFS_SCHEMA)
+    cursor.execute(SEMANTIC_REF_INDEX_SCHEMA)
+    cursor.execute(MESSAGE_TEXT_INDEX_SCHEMA)
+    cursor.execute(PROPERTY_INDEX_SCHEMA)
+    cursor.execute(RELATED_TERMS_ALIASES_SCHEMA)
+    cursor.execute(RELATED_TERMS_FUZZY_SCHEMA)
+    cursor.execute(TIMESTAMP_INDEX_SCHEMA)
+
+    # Create additional indexes
+    cursor.execute(SEMANTIC_REF_INDEX_TERM_INDEX)
+    cursor.execute(MESSAGE_TEXT_INDEX_MESSAGE_INDEX)
+    cursor.execute(MESSAGE_TEXT_INDEX_POSITION_INDEX)
+    cursor.execute(RELATED_TERMS_ALIASES_TERM_INDEX)
+    cursor.execute(RELATED_TERMS_ALIASES_ALIAS_INDEX)
+    cursor.execute(RELATED_TERMS_FUZZY_TERM_INDEX)
+
+
+def get_db_schema_version(db: sqlite3.Connection) -> str:
+    """Get the database schema version."""
+    try:
+        cursor = db.cursor()
+        cursor.execute("SELECT schema_version FROM ConversationMetadata LIMIT 1")
+        row = cursor.fetchone()
+        return row[0] if row else CONVERSATION_SCHEMA_VERSION
+    except sqlite3.OperationalError:
+        # Table doesn't exist, return current version
+        return CONVERSATION_SCHEMA_VERSION
+
+
+# Schema aliases for backward compatibility
+CONVERSATIONS_SCHEMA = CONVERSATION_METADATA_SCHEMA

typeagent/storage/sqlite/semrefindex.py

@@ -0,0 +1,156 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""SQLite-based semantic reference index implementation."""
+
+import re
+import sqlite3
+import unicodedata
+
+from ...knowpro import interfaces
+from ...knowpro.interfaces import ScoredSemanticRefOrdinal
+
+
+class SqliteTermToSemanticRefIndex(interfaces.ITermToSemanticRefIndex):
+    """SQLite-backed implementation of term to semantic ref index."""
+
+    def __init__(self, db: sqlite3.Connection):
+        self.db = db
+
+    async def size(self) -> int:
+        cursor = self.db.cursor()
+        cursor.execute("SELECT COUNT(DISTINCT term) FROM SemanticRefIndex")
+        return cursor.fetchone()[0]
+
+    async def get_terms(self) -> list[str]:
+        cursor = self.db.cursor()
+        cursor.execute("SELECT DISTINCT term FROM SemanticRefIndex ORDER BY term")
+        return [row[0] for row in cursor.fetchall()]
+
+    async def add_term(
+        self,
+        term: str,
+        semantic_ref_ordinal: (
+            interfaces.SemanticRefOrdinal | interfaces.ScoredSemanticRefOrdinal
+        ),
+    ) -> str:
+        if not term:
+            return term
+
+        term = self._prepare_term(term)
+
+        # Extract semref_id from the ordinal
+        if isinstance(semantic_ref_ordinal, interfaces.ScoredSemanticRefOrdinal):
+            semref_id = semantic_ref_ordinal.semantic_ref_ordinal
+        else:
+            semref_id = semantic_ref_ordinal
+
+        cursor = self.db.cursor()
+        cursor.execute(
+            """
+            INSERT OR IGNORE INTO SemanticRefIndex (term, semref_id)
+            VALUES (?, ?)
+            """,
+            (term, semref_id),
+        )
+
+        return term
+
+    async def remove_term(
+        self, term: str, semantic_ref_ordinal: interfaces.SemanticRefOrdinal
+    ) -> None:
+        term = self._prepare_term(term)
+        cursor = self.db.cursor()
+        cursor.execute(
+            "DELETE FROM SemanticRefIndex WHERE term = ? AND semref_id = ?",
+            (term, semantic_ref_ordinal),
+        )
+
+    async def lookup_term(
+        self, term: str
+    ) -> list[interfaces.ScoredSemanticRefOrdinal] | None:
+        term = self._prepare_term(term)
+        cursor = self.db.cursor()
+        cursor.execute(
+            "SELECT semref_id FROM SemanticRefIndex WHERE term = ?",
+            (term,),
+        )
+
+        # Return as ScoredSemanticRefOrdinal with default score of 1.0
+        results = []
+        for row in cursor.fetchall():
+            semref_id = row[0]
+            results.append(ScoredSemanticRefOrdinal(semref_id, 1.0))
+        return results
+
+    async def clear(self) -> None:
+        """Clear all terms from the semantic ref index."""
+        cursor = self.db.cursor()
+        cursor.execute("DELETE FROM SemanticRefIndex")
+
+    async def serialize(self) -> interfaces.TermToSemanticRefIndexData:
+        """Serialize the index data for compatibility with in-memory version."""
+        cursor = self.db.cursor()
+        cursor.execute(
+            "SELECT term, semref_id FROM SemanticRefIndex ORDER BY term, semref_id"
+        )
+
+        # Group by term
+        term_to_semrefs: dict[str, list[interfaces.ScoredSemanticRefOrdinalData]] = {}
+        for term, semref_id in cursor.fetchall():
+            if term not in term_to_semrefs:
+                term_to_semrefs[term] = []
+            scored_ref = ScoredSemanticRefOrdinal(semref_id, 1.0)
+            term_to_semrefs[term].append(scored_ref.serialize())
+
+        # Convert to the expected format
+        items = []
+        for term, semref_ordinals in term_to_semrefs.items():
+            items.append(
+                interfaces.TermToSemanticRefIndexItemData(
+                    term=term, semanticRefOrdinals=semref_ordinals
+                )
+            )
+
+        return interfaces.TermToSemanticRefIndexData(items=items)
+
+    async def deserialize(self, data: interfaces.TermToSemanticRefIndexData) -> None:
+        """Deserialize index data by populating the SQLite table."""
+        cursor = self.db.cursor()
+
+        # Clear existing data
+        cursor.execute("DELETE FROM SemanticRefIndex")
+
+        # Prepare all insertion data for bulk operation
+        insertion_data = []
+        for item in data["items"]:
+            if item and item["term"]:
+                term = self._prepare_term(item["term"])
+                for semref_ordinal_data in item["semanticRefOrdinals"]:
+                    if isinstance(semref_ordinal_data, dict):
+                        semref_id = semref_ordinal_data["semanticRefOrdinal"]
+                    else:
+                        # Fallback for direct integer
+                        semref_id = semref_ordinal_data
+                    insertion_data.append((term, semref_id))
+
+        # Bulk insert all the data
+        if insertion_data:
+            cursor.executemany(
+                "INSERT OR IGNORE INTO SemanticRefIndex (term, semref_id) VALUES (?, ?)",
+                insertion_data,
+            )
+
+    def _prepare_term(self, term: str) -> str:
+        """Normalize term by converting to lowercase, stripping whitespace, and normalizing Unicode."""
+        # Strip leading/trailing whitespace
+        term = term.strip()
+
+        # Normalize Unicode to NFC form (canonical composition)
+        term = unicodedata.normalize("NFC", term)
+
+        # Collapse multiple whitespace characters to single space
+        term = re.sub(r"\s+", " ", term)
+
+        # Convert to lowercase
+        return term.lower()

typeagent/storage/sqlite/timestampindex.py

@@ -0,0 +1,146 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""SQLite-based timestamp index implementation."""
+
+import sqlite3
+
+from ...knowpro import interfaces
+
+
+class SqliteTimestampToTextRangeIndex(interfaces.ITimestampToTextRangeIndex):
+    """SQL-based timestamp index that queries Messages table directly."""
+
+    def __init__(self, db: sqlite3.Connection):
+        self.db = db
+
+    async def size(self) -> int:
+        return self._size()
+
+    def _size(self) -> int:
+        cursor = self.db.cursor()
+        cursor.execute(
+            "SELECT COUNT(*) FROM Messages WHERE start_timestamp IS NOT NULL"
+        )
+        return cursor.fetchone()[0]
+
+    async def add_timestamp(
+        self, message_ordinal: interfaces.MessageOrdinal, timestamp: str
+    ) -> bool:
+        return self._add_timestamp(message_ordinal, timestamp)
+
+    def _add_timestamp(
+        self, message_ordinal: interfaces.MessageOrdinal, timestamp: str
+    ) -> bool:
+        """Add timestamp to Messages table start_timestamp column."""
+        cursor = self.db.cursor()
+        cursor.execute(
+            "UPDATE Messages SET start_timestamp = ? WHERE msg_id = ?",
+            (timestamp, message_ordinal),
+        )
+        return cursor.rowcount > 0
+
+    async def get_timestamp_ranges(
+        self, start_timestamp: str, end_timestamp: str | None = None
+    ) -> list[interfaces.TimestampedTextRange]:
+        """Get timestamp ranges from Messages table."""
+        cursor = self.db.cursor()
+
+        if end_timestamp is None:
+            # Single timestamp query
+            cursor.execute(
+                """
+                SELECT msg_id, start_timestamp
+                FROM Messages
+                WHERE start_timestamp = ?
+                ORDER BY msg_id
+                """,
+                (start_timestamp,),
+            )
+        else:
+            # Range query
+            cursor.execute(
+                """
+                SELECT msg_id, start_timestamp
+                FROM Messages
+                WHERE start_timestamp >= ? AND start_timestamp <= ?
+                ORDER BY msg_id
+                """,
+                (start_timestamp, end_timestamp),
+            )
+
+        results = []
+        for msg_id, timestamp in cursor.fetchall():
+            # Create text range for message
+            from ...knowpro.interfaces import TextLocation, TextRange
+
+            text_range = TextRange(
+                start=TextLocation(message_ordinal=msg_id, chunk_ordinal=0)
+            )
+            results.append(
+                interfaces.TimestampedTextRange(range=text_range, timestamp=timestamp)
+            )
+
+        return results
+
+    async def add_timestamps(
+        self, message_timestamps: list[tuple[interfaces.MessageOrdinal, str]]
+    ) -> None:
+        """Add multiple timestamps."""
+        cursor = self.db.cursor()
+        for message_ordinal, timestamp in message_timestamps:
+            cursor.execute(
+                "UPDATE Messages SET start_timestamp = ? WHERE msg_id = ?",
+                (timestamp, message_ordinal),
+            )
+
+    async def lookup_range(
+        self, date_range: interfaces.DateRange
+    ) -> list[interfaces.TimestampedTextRange]:
+        """Lookup messages in a date range."""
+        cursor = self.db.cursor()
+
+        # Convert datetime objects to ISO format strings for comparison
+        start_timestamp = date_range.start.isoformat().replace("+00:00", "Z")
+        end_timestamp = (
+            date_range.end.isoformat().replace("+00:00", "Z")
+            if date_range.end
+            else None
+        )
+
+        if date_range.end is None:
+            # Point query
+            cursor.execute(
+                """
+                SELECT msg_id, start_timestamp, chunks
+                FROM Messages
+                WHERE start_timestamp = ?
+                ORDER BY msg_id
+                """,
+                (start_timestamp,),
+            )
+        else:
+            # Range query
+            cursor.execute(
+                """
+                SELECT msg_id, start_timestamp, chunks
+                FROM Messages
+                WHERE start_timestamp >= ? AND start_timestamp < ?
+                ORDER BY msg_id
+                """,
+                (start_timestamp, end_timestamp),
+            )
+
+        results = []
+        for msg_id, timestamp, chunks in cursor.fetchall():
+            text_location = interfaces.TextLocation(
+                message_ordinal=msg_id, chunk_ordinal=0
+            )
+            text_range = interfaces.TextRange(
+                start=text_location, end=None  # Point range
+            )
+            results.append(
+                interfaces.TimestampedTextRange(timestamp=timestamp, range=text_range)
+            )
+
+        return results

typeagent/storage/utils.py

@@ -0,0 +1,41 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Storage provider utilities.
+
+This module provides utility functions for creating storage providers
+without circular import issues.
+"""
+
+from ..knowpro.interfaces import IMessage, IStorageProvider
+from ..knowpro.convsettings import MessageTextIndexSettings, RelatedTermIndexSettings
+
+
+async def create_storage_provider[TMessage: IMessage](
+    message_text_settings: MessageTextIndexSettings,
+    related_terms_settings: RelatedTermIndexSettings,
+    dbname: str | None = None,
+    message_type: type[TMessage] | None = None,
+) -> IStorageProvider[TMessage]:
+    """Create a storage provider.
+
+    MemoryStorageProvider if dbname is None, SqliteStorageProvider otherwise.
+    """
+    if dbname is None:
+        from .memory import MemoryStorageProvider
+
+        return MemoryStorageProvider(message_text_settings, related_terms_settings)
+    else:
+        from .sqlite import SqliteStorageProvider
+
+        if message_type is None:
+            raise ValueError("Message type must be specified for SQLite storage")
+
+        # Create the new provider directly (constructor is now synchronous)
+        provider = SqliteStorageProvider(
+            db_path=dbname,
+            message_type=message_type,
+            message_text_index_settings=message_text_settings,
+            related_term_index_settings=related_terms_settings,
+        )
+        return provider

typeagent_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: typeagent-py
+Version: 0.1.0
+Summary: TypeAgent implements an agentic memory framework.
+Author: Steven Lucco, Umesh Madan, Guido van Rossum
+Author-email: Guido van Rossum <gvanrossum@microsoft.com>
+Project-URL: Homepage, https://github.com/microsoft/TypeAgent/tree/main/python/ta
+Requires-Python: <3.14,>=3.12
+License-File: LICENSE
+Requires-Dist: azure-identity>=1.22.0
+Requires-Dist: black>=25.1.0
+Requires-Dist: build>=1.2.2.post1
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: coverage[toml]>=7.9.1
+Requires-Dist: logfire>=4.1.0
+Requires-Dist: mcp[cli]>=1.12.1
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: openai>=1.81.0
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.57b0
+Requires-Dist: pydantic>=2.11.4
+Requires-Dist: pydantic-ai-slim[openai]>=0.5.0
+Requires-Dist: pyright>=1.1.405
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: pytest-asyncio>=0.26.0
+Requires-Dist: pytest-mock>=3.14.0
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: typechat
+Dynamic: license-file

typeagent_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+typeagent/aitools/auth.py,sha256=bnHqU8G3hDW2A50ulwmFeUfz0OzaGzyVKQUMXoUmqao,1659
+typeagent/aitools/embeddings.py,sha256=Bveu0SXXUvsGDPoyLeCB6DE86o8-PQnaR9KJ1z7oIo0,9490
+typeagent/aitools/utils.py,sha256=3EQVBf3uFEdqN_xQdHZbf8PVt6vic4XCPST7QjT4NC8,8027
+typeagent/aitools/vectorbase.py,sha256=zdTM1mKkD49pKcUC5xeXmNcQZzUCX73SOugGwU8FeSc,6340
+typeagent/knowpro/answer_context_schema.py,sha256=dIlTmUC3VT0Q_5ybVTDY2jVPA6KH1407EBBCsKYpqb8,1627
+typeagent/knowpro/answer_response_schema.py,sha256=bo-owIba8WaeKPve_NQx86kHIrnDujlUPcCVBP34-aI,990
+typeagent/knowpro/answers.py,sha256=P4urCHqkLZa-h57HLadrnvwIHeSKWz1mYCVVcKKKQwo,20131
+typeagent/knowpro/collections.py,sha256=llBt1mmPm9DRc9OIIKcCpzpNQapSP6jA3ojlohfFgPs,25663
+typeagent/knowpro/common.py,sha256=H087hBsHhPrwVM2m3PIIbAKNkwjfWl00R13JB-nTyQ4,261
+typeagent/knowpro/convknowledge.py,sha256=jAoXRrd_6g8NOxjAXPPz_SFMhsZDnBsnxn1xOXxwHyA,4165
+typeagent/knowpro/convsettings.py,sha256=o_f2-PFXUpzNi7WYOKaickOaBTVAj4aaYUpR13g8I0k,3514
+typeagent/knowpro/convutils.py,sha256=jiUtbhSDbKe4wi_2uglVI7p_DsdJNd9uTo-wvgKEMS8,1564
+typeagent/knowpro/date_time_schema.py,sha256=42HdjWsyDR6REwpZSiNz-4TwMHWQHpGtPu4TFUSzHxU,536
+typeagent/knowpro/field_helpers.py,sha256=El2pOEsRUwJDQ-mohW7O78bcnbEnciCtV_RpZqFFoCU,3109
+typeagent/knowpro/fuzzyindex.py,sha256=CewYKAM-OqEuhtqAmhSTRfnSKxAIOxOLy0yRwKjWlgI,4935
+typeagent/knowpro/interfaces.py,sha256=wSbgE3RATBmN5y9cimHOKOSJ4mg-zisOB8-xYA1TdtU,24087
+typeagent/knowpro/knowledge.py,sha256=lbEMOTZZmKpS-ldFyV9RXb--g9eZhLAuJnFKqHRzX6s,3004
+typeagent/knowpro/kplib.py,sha256=CIW2LsS2ZFUV5w1cQG1DBOg9qgkgPJDaEnZv_nYh5rQ,3819
+typeagent/knowpro/query.py,sha256=8i1fY4fxt9WMbqYx5-t_9VEjpZzy1-bzHeZVKuaB21M,39726
+typeagent/knowpro/search.py,sha256=iUbTv53XBQYw5hqsedouEpi6KfLs9VSIZZ-M752Si5Y,22992
+typeagent/knowpro/search_query_schema.py,sha256=Xn9n11M8f4jFc-ICz8i_3cf2LBLwUzl52ctneqbKa6g,5583
+typeagent/knowpro/searchlang.py,sha256=bYEetPVgdEmkc3Nmw1bPmJ59QonkUpZwKclRKXrt3Z4,26731
+typeagent/knowpro/searchlib.py,sha256=p9nDFQwI9aZVqltJ78WVXO08OwBPCPQvg9yxgX-S6AU,9703
+typeagent/knowpro/secindex.py,sha256=KPweoLG2ozx5sayfD16dZ1X3BP5Fc4BhIar86WAU1ak,3706
+typeagent/knowpro/serialization.py,sha256=46_uX3yJf29uWaXWuT6fARUvdC1BmsgPcxQxNzunvso,13065
+typeagent/knowpro/textlocindex.py,sha256=Esy67bXYtyqWdj5dwfAsVBaA-0FzhiZHekYfyhtpzpw,5955
+typeagent/knowpro/utils.py,sha256=UqilFoWBi507hDEDFxmFNm-QlihTdPZa-ESIohP7xws,474
+typeagent/mcp/server.py,sha256=pvQRekhD28nYt-3iV5-2I7hPgjnGIHoPbcILkUh_Z-o,4573
+typeagent/podcasts/podcast.py,sha256=WHpzYo1Kz-rkyhNBRy4oc38pQaQy3dVTmy7SCShgPgM,18488
+typeagent/podcasts/podcast_import.py,sha256=Au9a2qaiEZT9RmRP6gCUNqLTiJJ2fRDh7OYGVM7uouE,3694
+typeagent/storage/__init__.py,sha256=nzXmnjCld060avN92QgkkbKSkunMr7hhrhUY9g9r2dY,589
+typeagent/storage/utils.py,sha256=EF2wzp94hF4qqOGhiJIUq94SNbYoElyF6NhomDk0nJ8,1437
+typeagent/storage/memory/__init__.py,sha256=6NtHL0sOIRxALBb28wjKXc80PF_Vn3b1HNXldQXiajs,351
+typeagent/storage/memory/collections.py,sha256=alhOo8proevJKINBF5iqPtmRdSKZ2ROkD2D7L3vnnUc,1993
+typeagent/storage/memory/convthreads.py,sha256=PKbtJr7MPq4325UNb-DNWbxTJWFkcBQoo9P76ZqIhL8,2685
+typeagent/storage/memory/messageindex.py,sha256=zd10U6E-cB7Bg2G9ivJU3ua51UeHI-twZPOd5ler3iM,6803
+typeagent/storage/memory/propindex.py,sha256=fpH7296L2B6JQ0dplHZY8KYDXxY55sup3bZrvY2Pzp0,9797
+typeagent/storage/memory/provider.py,sha256=HH3v1UAdfL_k-0BRDPPoUZsMdayAFyTAZ14xaxM_eCE,3241
+typeagent/storage/memory/reltermsindex.py,sha256=Y_SpZYcXvRkhp3AThfbtNe7RLgbHvYsDjM7t1rdq0jY,11813
+typeagent/storage/memory/semrefindex.py,sha256=kUxw7s9boj5cHLz-ywrohKTmxPUzXRCG7xHL_fwgNW0,21279
+typeagent/storage/memory/timestampindex.py,sha256=6OFJnncKjvVhMpfaQBOWhG1ozuV1PRTdoFGtPoQk-uw,6361
+typeagent/storage/sqlite/__init__.py,sha256=eriIYr7iDFctxax-OmI1eGlrBqoYL3Jta6vruishPfM,947
+typeagent/storage/sqlite/collections.py,sha256=5O_fUICw1Cdr510ek8sIgLqSw1JPVqoKxV0TPyeQrrs,12817
+typeagent/storage/sqlite/messageindex.py,sha256=VkXPPGnqgK42HX0jCsQBhC16lbe9I-wopkUY707Yy-0,14328
+typeagent/storage/sqlite/propindex.py,sha256=nWfVPH4XBtNGp6rrAsbwgclXn6pL9W0SquSdcPwRv3k,4240
+typeagent/storage/sqlite/provider.py,sha256=XrUAdi6NMNdYzG0F96WvIFi8QxQ6wHjGSmGLHUrUwL8,11552
+typeagent/storage/sqlite/reltermsindex.py,sha256=VwmUH-awNZ5YeMZTuFVfKP-8G0WQQ1klFq2I4KEOykY,12568
+typeagent/storage/sqlite/schema.py,sha256=c5-dff8wdIA37SegPOI-_h-w2eCPSnpnPQAC3vcNzYo,8061
+typeagent/storage/sqlite/semrefindex.py,sha256=eqHrQMyVdFS9HOXV1dLvp0bMs8JKoPQLmV46Cs0HQJM,5456
+typeagent/storage/sqlite/timestampindex.py,sha256=gnmmwgRKCwFi2iGzGJVe7Zz12rblB-5-5WZkqpDgySM,4764
+typeagent_py-0.1.0.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+typeagent_py-0.1.0.dist-info/METADATA,sha256=BA3AfIIF4hAKz9m-WlqH3bC82lGGL6jaFS__1SyLuxs,1002
+typeagent_py-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+typeagent_py-0.1.0.dist-info/top_level.txt,sha256=uXuso6jrsvRIIZsh6WfAvTjk5wOgClsFUiiuo1hpFZ8,10
+typeagent_py-0.1.0.dist-info/RECORD,,

typeagent_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+