amsdal_ml 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

amsdal_ml/__about__.py

@@ -1 +1 @@
-__version__ = '0.1.0'
+__version__ = '0.1.2'

amsdal_ml/agents/agent.py

@@ -6,10 +6,13 @@ from collections.abc import AsyncIterator
 from collections.abc import Iterator
 from typing import Any
 from typing import Literal
+from typing import Optional
 
 from pydantic import BaseModel
 from pydantic import Field
 
+from amsdal_ml.fileio.base_loader import FileAttachment
+
 
 class AgentMessage(BaseModel):
     role: Literal["SYSTEM", "USER", "ASSISTANT"]
@@ -24,16 +27,37 @@ class AgentOutput(BaseModel):
 
 class Agent(ABC):
     @abstractmethod
-    async def arun(self, user_query: str) -> AgentOutput: ...
-    @abstractmethod
-    async def astream(self, user_query: str) -> AsyncIterator[str]:
-        """Yield streamed chunks for the given query."""
-        raise NotImplementedError
+    async def arun(
+        self,
+        user_query: str,
+        *,
+        attachments: Optional[list[FileAttachment]] = None,
+    ) -> AgentOutput:
+        ...
 
-    def run(self, user_query: str) -> AgentOutput:
+    @abstractmethod
+    async def astream(
+        self,
+        user_query: str,
+        *,
+        attachments: Optional[list[FileAttachment]] = None,
+    ) -> AsyncIterator[str]:
+        ...
+
+    def run(
+        self,
+        user_query: str,
+        *,
+        attachments: Optional[list[FileAttachment]] = None,
+    ) -> AgentOutput:
         msg = "This agent is async-only. Use arun()."
         raise NotImplementedError(msg)
 
-    def stream(self, user_query: str) -> Iterator[str]:
+    def stream(
+        self,
+        user_query: str,
+        *,
+        attachments: Optional[list[FileAttachment]] = None,
+    ) -> Iterator[str]:
         msg = "This agent is async-only. Use astream()."
         raise NotImplementedError(msg)

amsdal_ml/agents/default_qa_agent.py

@@ -13,6 +13,7 @@ from typing import no_type_check
 from amsdal_ml.agents.agent import Agent
 from amsdal_ml.agents.agent import AgentOutput
 from amsdal_ml.agents.promts import get_prompt
+from amsdal_ml.fileio.base_loader import FileAttachment
 from amsdal_ml.mcp_client.base import ToolClient
 from amsdal_ml.mcp_client.base import ToolInfo
 from amsdal_ml.ml_models.models import MLModel
@@ -30,6 +31,9 @@ _FINAL_RE = re.compile(
     r"Final Answer:\s*(?P<answer>.+)",
     re.DOTALL | re.IGNORECASE,
 )
+# ---------- constants ----------
+
+_MAX_PARSE_RETRIES = 5
 
 
 
@@ -186,11 +190,11 @@ class DefaultQAAgent(Agent):
             return str(content)
 
     # ---------- core run ----------
-    def run(self, _user_query: str) -> AgentOutput:
+    def run(self, user_query: str, *, attachments: list[FileAttachment] | None = None) -> AgentOutput:
         msg = "DefaultQAAgent is async-only for now. Use arun()."
         raise NotImplementedError(msg)
 
-    async def _run_async(self, user_query: str) -> AgentOutput:
+    async def _run_async(self, user_query: str, *, attachments: list[FileAttachment] | None = None) -> AgentOutput:
         if self._tool_clients and not self._tools_index_built:
             await self._build_clients_index()
 
@@ -198,10 +202,12 @@ class DefaultQAAgent(Agent):
         used_tools: list[str] = []
         parse_retries = 0
 
+
         for _ in range(self.max_steps):
             prompt = self._react_text(user_query, scratch)
-            out = await self.model.ainvoke(prompt)
-
+            out = await self.model.ainvoke(prompt, attachments=attachments)
+            print("Model output:", out)  # noqa: T201
+            print('promt:', prompt)  # noqa: T201
             m_final = _FINAL_RE.search(out or "")
             if m_final:
                 return AgentOutput(
@@ -213,7 +219,7 @@ class DefaultQAAgent(Agent):
             m_tool = _TOOL_CALL_RE.search(out or "")
             if not m_tool:
                 parse_retries += 1
-                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= 1:
+                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= _MAX_PARSE_RETRIES:
                     msg = (
                         "Invalid ReAct output. Expected EXACT format (Final or Tool-call). "
                         f"Got:\n{out}"
@@ -221,6 +227,7 @@ class DefaultQAAgent(Agent):
                     raise ValueError(
                         msg
                     )
+
                 scratch += (
                     "\nThought: Previous output violated the strict format. "
                     "Reply again using EXACTLY one of the two specified formats.\n"
@@ -237,7 +244,7 @@ class DefaultQAAgent(Agent):
                     raise ValueError(msg)
             except Exception as e:
                 parse_retries += 1
-                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= 1:
+                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= _MAX_PARSE_RETRIES:
                     msg = f"Invalid Action Input JSON: {raw_input!r} ({e})"
                     raise ValueError(msg) from e
                 scratch += (
@@ -250,6 +257,7 @@ class DefaultQAAgent(Agent):
 
             try:
                 result = await tool.run(args, context=None, convert_result=True)
+                print("Similarity search result:", result)  # noqa: T201
             except Exception as e:
                 # unified error payload
                 err = {
@@ -276,12 +284,12 @@ class DefaultQAAgent(Agent):
         return self._stopped_response(used_tools)
 
     # ---------- public APIs ----------
-    async def arun(self, user_query: str) -> AgentOutput:
-        return await self._run_async(user_query)
+    async def arun(self, user_query: str, *, attachments: list[FileAttachment] | None = None) -> AgentOutput:
+        return await self._run_async(user_query, attachments=attachments)
 
     # ---------- streaming ----------
     @no_type_check
-    async def astream(self, user_query: str) -> AsyncIterator[str]:
+    async def astream(self, user_query: str, *, attachments: list[FileAttachment] | None = None) -> AsyncIterator[str]:
         if self._tool_clients and not self._tools_index_built:
             await self._build_clients_index()
 
@@ -296,7 +304,7 @@ class DefaultQAAgent(Agent):
 
             # Normalize model.astream: it might be an async iterator already,
             # or a coroutine (or nested coroutines) that resolves to one.
-            _val = self.model.astream(prompt)
+            _val = self.model.astream(prompt, attachments=attachments)
             while inspect.iscoroutine(_val):
                 _val = await _val
 
@@ -320,7 +328,7 @@ class DefaultQAAgent(Agent):
             m_tool = _TOOL_CALL_RE.search(buffer or "")
             if not m_tool:
                 parse_retries += 1
-                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= 1:
+                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= _MAX_PARSE_RETRIES:
                     msg = f"Invalid ReAct output (stream). Expected EXACT format. Got:\n{buffer}"
                     raise ValueError(msg)
                 scratch += (
@@ -339,7 +347,7 @@ class DefaultQAAgent(Agent):
                     raise ValueError(msg)
             except Exception as e:
                 parse_retries += 1
-                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= 1:
+                if self.on_parse_error == ParseErrorMode.RAISE or parse_retries >= _MAX_PARSE_RETRIES:
                     msg = f"Invalid Action Input JSON: {raw_input!r} ({e})"
                     raise ValueError(msg) from e
                 scratch += (

amsdal_ml/agents/promts/react_chat.prompt

@@ -21,7 +21,16 @@ RULES
 - `Action Input` MUST be a valid ONE-LINE JSON object (e.g. {{"a": 1, "b": 2}}).
 - Do NOT add anything before/after the block.
 - Do NOT print "Observation". The system will add it after tool execution.
-
+- You CAN read and use any attached files provided by the platform (including PDFs). Do not claim inability to view files.
+- Prefer not to use tools when the answer is fully supported by the user’s message and/or attached files. Use a tool only if it materially improves accuracy or retrieves missing facts.
+- If information is insufficient, answer concisely with: “I don’t have enough data to answer.”
+- Be deterministic and concise. No preambles, no meta-commentary, no Markdown.
+- Numbers: preserve exact figures, units, and percentages; do not round unless asked.
+- If you choose a tool:
+  - Use exactly one tool per step.
+  - The Action Input MUST be a single-line valid JSON object that matches the tool’s schema.
+  - If a tool errors or returns nothing useful, switch to the other format and produce a Final Answer.
+  
 PREVIOUS CONVERSATION
 --------------------
 {chat_history}

amsdal_ml/agents/retriever_tool.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import logging
+import sys
 from typing import Any
 from typing import Optional
 
@@ -9,6 +11,14 @@ from pydantic import Field
 
 from amsdal_ml.ml_retrievers.openai_retriever import OpenAIRetriever
 
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    handlers=[
+        logging.FileHandler("server2.log"),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
 
 class RetrieverArgs(BaseModel):
     query: str = Field(..., description='User search query')
@@ -20,13 +30,22 @@ class RetrieverArgs(BaseModel):
 _retriever = OpenAIRetriever()
 
 
-async def retriever_search(args: RetrieverArgs) -> list[dict[str, Any]]:
+async def retriever_search(
+    query: str = Field(..., description='User search query'),
+    k: int = 5,
+    include_tags: Optional[list[str]] = None,
+    exclude_tags: Optional[list[str]] = None,
+) -> list[dict[str, Any]]:
+    logging.info(
+        f"retriever_search called with query={query}, k={k}, include_tags={include_tags}, exclude_tags={exclude_tags}"
+    )
     chunks = await _retriever.asimilarity_search(
-        query=args.query,
-        k=args.k,
-        include_tags=args.include_tags,
-        exclude_tags=args.exclude_tags,
+        query=query,
+        k=k,
+        include_tags=include_tags,
+        exclude_tags=exclude_tags,
     )
+    logging.info(f"retriever_search found {len(chunks)} chunks: {chunks}")
     out: list[dict[str, Any]] = []
     for c in chunks:
         if hasattr(c, 'model_dump'):
@@ -42,7 +61,7 @@ async def retriever_search(args: RetrieverArgs) -> list[dict[str, Any]]:
 
 retriever_tool = Tool.from_function(
     retriever_search,
-    name='retriever.search',
+    name='search',
     description='Semantic search in knowledge base (OpenAI embeddings)',
     structured_output=True,
 )

amsdal_ml/fileio/base_loader.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from abc import ABC
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any
+from typing import BinaryIO
+from typing import Optional
+
+from pydantic import BaseModel
+
+PLAIN_TEXT = "plain_text"
+FILE_ID = "file_id"
+
+
+class FileData(BaseModel):
+    name: str
+    size: int | None = None
+    mime: Optional[str] = None
+
+
+@dataclass
+class FileAttachment:
+    type: str  # one of: PLAIN_TEXT, FILE_ID
+    content: Any
+    metadata: dict[str, Any] | None = None
+
+    def __post_init__(self) -> None:
+        if self.metadata is None:
+            self.metadata = {}
+
+
+@dataclass
+class FileItem:
+    file: BinaryIO
+    filename: str | None = None
+    filedata: FileData | None = None
+
+    @staticmethod
+    def from_path(path: str, *, filedata: FileData | None = None) -> FileItem:
+        # Caller is responsible for lifecycle; loaders may close after upload.
+        f = open(path, "rb")
+        return FileItem(file=f, filename=path.split("/")[-1], filedata=filedata)
+
+    @staticmethod
+    def from_bytes(data: bytes, *, filename: str | None = None, filedata: FileData | None = None) -> FileItem:
+        import io
+        return FileItem(file=io.BytesIO(data), filename=filename, filedata=filedata)
+
+    @staticmethod
+    def from_str(text: str, *, filename: str | None = None, filedata: FileData | None = None) -> FileItem:
+        import io
+        return FileItem(file=io.BytesIO(text.encode("utf-8")), filename=filename, filedata=filedata)
+
+
+class BaseFileLoader(ABC):
+    @abstractmethod
+    async def load(self, item: FileItem) -> FileAttachment:
+        """Upload a single file and return an attachment reference."""
+
+    @abstractmethod
+    async def load_batch(self, items: list[FileItem]) -> list[FileAttachment]:
+        """Upload multiple files; input and output are lists for simplicity."""

amsdal_ml/fileio/openai_loader.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import asyncio
+import io
+import logging
+from collections.abc import Sequence
+from typing import Any
+from typing import BinaryIO
+from typing import Literal
+
+from openai import AsyncOpenAI
+
+from amsdal_ml.fileio.base_loader import FILE_ID
+from amsdal_ml.fileio.base_loader import BaseFileLoader
+from amsdal_ml.fileio.base_loader import FileAttachment
+from amsdal_ml.fileio.base_loader import FileData
+from amsdal_ml.fileio.base_loader import FileItem
+
+logger = logging.getLogger(__name__)
+
+AllowedPurpose = Literal["assistants", "batch", "fine-tune", "vision", "user_data", "evals"]
+
+
+class OpenAIFileLoader(BaseFileLoader):
+    """
+    Loader which uploads files into OpenAI Files API and returns openai_file_id.
+    """
+
+    def __init__(self, client: AsyncOpenAI, *, purpose: AllowedPurpose = "assistants") -> None:
+        self.client = client
+        self.purpose: AllowedPurpose = purpose  # mypy: Literal union, matches SDK
+
+    async def _upload_one(self, file: BinaryIO, *, filename: str | None, filedata: FileData | None) -> FileAttachment:
+        try:
+            if hasattr(file, "seek"):
+                file.seek(0)
+        except Exception as exc:  # pragma: no cover
+            logger.debug("seek(0) failed for %r: %s", filename or file, exc)
+
+        buf = file if isinstance(file, io.BytesIO) else io.BytesIO(file.read())
+
+        up = await self.client.files.create(file=(filename or "upload.bin", buf), purpose=self.purpose)
+
+        meta: dict[str, Any] = {
+            "filename": filename,
+            "provider": "openai",
+            "file": {
+                "id": up.id,
+                "bytes": getattr(up, "bytes", None),
+                "purpose": getattr(up, "purpose", self.purpose),
+                "created_at": getattr(up, "created_at", None),
+                "status": getattr(up, "status", None),
+                "status_details": getattr(up, "status_details", None),
+            },
+        }
+        if filedata is not None:
+            meta["filedata"] = filedata.model_dump()
+
+        return FileAttachment(type=FILE_ID, content=up.id, metadata=meta)
+
+    async def load(self, item: FileItem) -> FileAttachment:
+        return await self._upload_one(item.file, filename=item.filename, filedata=item.filedata)
+
+    async def load_batch(self, items: Sequence[FileItem]) -> list[FileAttachment]:
+        tasks = [
+            asyncio.create_task(self._upload_one(it.file, filename=it.filename, filedata=it.filedata))
+            for it in items
+        ]
+        return await asyncio.gather(*tasks)

amsdal_ml/mcp_client/stdio_client.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 from collections.abc import Iterable
 from contextlib import AsyncExitStack
 from typing import Any
 
+from amsdal_utils.config.manager import AmsdalConfigManager
 from mcp import ClientSession
 from mcp import StdioServerParameters
 from mcp.client.stdio import stdio_client
@@ -19,7 +21,14 @@ class StdioClient(ToolClient):
     MCP over STDIO client.
     """
 
-    def __init__(self, alias: str, module_or_cmd: str, *args: str, persist_session: bool = True):
+    def __init__(
+    self,
+    alias: str,
+    module_or_cmd: str,
+    *args: str,
+    persist_session: bool = True,
+    send_amsdal_config: bool = True,
+    ):
         self.alias = alias
         if module_or_cmd in ("python", "python3"):
             self._command = module_or_cmd
@@ -27,7 +36,9 @@ class StdioClient(ToolClient):
         else:
             self._command = "python"
             self._args = ["-m", module_or_cmd]
-
+        if send_amsdal_config:
+            self._args.append("--amsdal-config")
+            self._args.append(self._build_amsdal_config_arg())
         self._persist = persist_session
         self._lock = asyncio.Lock()
         self._stack: AsyncExitStack | None = None
@@ -115,6 +126,7 @@ class StdioClient(ToolClient):
                 rx, tx = await stack.enter_async_context(stdio_client(params))
                 s = await stack.enter_async_context(ClientSession(rx, tx))
                 await s.initialize()
+                print("Calling tool:", tool_name, "with args:", args)  # noqa: T201
                 res = await self._call_with_timeout(s.call_tool(tool_name, args), timeout=timeout)
                 return getattr(res, "content", res)
 
@@ -128,3 +140,11 @@ class StdioClient(ToolClient):
             s = await self._ensure_session()
             res = await self._call_with_timeout(s.call_tool(tool_name, args), timeout=timeout)
             return getattr(res, "content", res)
+
+    def _build_amsdal_config_arg(self) -> str:
+        """
+        Build a JSON string argument representing the current Amsdal configuration.
+        This can be passed to the subprocess to ensure it has the same configuration context.
+        """
+        config = AmsdalConfigManager().get_config()
+        return base64.b64encode(config.model_dump_json().encode('utf-8')).decode('utf-8')

amsdal_ml/mcp_server/server_retriever_stdio.py

@@ -1,11 +1,59 @@
+import argparse
+import asyncio
+import base64
+import json
+import logging
+import sys
+from typing import Any
+from typing import cast
+
+from amsdal.manager import AmsdalManager
+from amsdal.manager import AsyncAmsdalManager
+from amsdal_utils.config.data_models.amsdal_config import AmsdalConfig
+from amsdal_utils.config.manager import AmsdalConfigManager
 from mcp.server.fastmcp import FastMCP
 
 from amsdal_ml.agents.retriever_tool import retriever_search
 
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    handlers=[
+        logging.FileHandler("server.log"),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--amsdal-config", required=False, help="Base64-encoded config string")
+args = parser.parse_args()
+
+logging.info(f"Starting server with args: {args}")
+
+if args.amsdal_config:
+    decoded = base64.b64decode(args.amsdal_config).decode("utf-8")
+    amsdal_config = AmsdalConfig(**json.loads(decoded))
+    logging.info(f"Loaded Amsdal config: {amsdal_config}")
+    AmsdalConfigManager().set_config(amsdal_config)
+
+    manager: Any
+    if amsdal_config.async_mode:
+        manager = AsyncAmsdalManager()
+        logging.info("pre-setup")
+        asyncio.run(cast(Any, manager).setup())
+        logging.info("post-setup")
+        asyncio.run(cast(Any, manager).post_setup())
+        logging.info("manager inited")
+    else:
+        manager = AmsdalManager()
+        cast(Any, manager).setup()
+        cast(Any, manager).post_setup()
+
 server = FastMCP('retriever-stdio')
 server.tool(
-    name='retriever.search',
+    name='search',
     description='Semantic search in knowledge base (OpenAI embeddings)',
     structured_output=True,
 )(retriever_search)
+
 server.run(transport='stdio')

amsdal_ml/migrations/0000_initial.py

@@ -0,0 +1,36 @@
+from amsdal_models.migration import migrations
+from amsdal_utils.models.enums import ModuleType
+
+
+class Migration(migrations.Migration):
+    operations: list[migrations.Operation] = [
+        migrations.CreateClass(
+            module_type=ModuleType.CONTRIB,
+            class_name="EmbeddingModel",
+            new_schema={
+                "title": "EmbeddingModel",
+                "required": ["data_object_class", "data_object_id", "chunk_index", "raw_text", "embedding"],
+                "properties": {
+                    "data_object_class": {"type": "string", "title": "Linked object class"},
+                    "data_object_id": {"type": "string", "title": "Linked object ID"},
+                    "chunk_index": {"type": "integer", "title": "Chunk index"},
+                    "raw_text": {"type": "string", "title": "Raw text used for embedding"},
+                    "embedding": {
+                        "type": "array",
+                        "items": {"type": "number"},
+                        "title": "Embedding",
+                        "additional_type": "vector",
+                        "dimensions": 1536,
+                    },
+                    "tags": {"type": "array", "items": {"type": "string"}, "title": "Embedding tags"},
+                    "ml_metadata": {"type": "anything", "title": "ML metadata"},
+                },
+                "storage_metadata": {
+                    "table_name": "embedding_model",
+                    "db_fields": {},
+                    "primary_key": ["partition_key"],
+                    "foreign_keys": {},
+                },
+            },
+        ),
+    ]

amsdal_ml/ml_ingesting/default_ingesting.py

@@ -288,8 +288,8 @@ class DefaultIngesting(MLIngesting):
         object_class, object_id = self._resolve_link(instance)
         objs = [
             EmbeddingModel(
-                object_class=object_class,
-                object_id=object_id,
+                data_object_class=object_class,
+                data_object_id=object_id,
                 chunk_index=r.chunk_index,
                 raw_text=r.raw_text,
                 embedding=r.embedding,
@@ -305,8 +305,8 @@ class DefaultIngesting(MLIngesting):
         object_class, object_id = self._resolve_link(instance)
         objs = [
             EmbeddingModel(
-                object_class=object_class,
-                object_id=object_id,
+                data_object_class=object_class,
+                data_object_id=object_id,
                 chunk_index=r.chunk_index,
                 raw_text=r.raw_text,
                 embedding=r.embedding,

amsdal_ml/ml_models/models.py

@@ -1,5 +1,11 @@
+from __future__ import annotations
+
 from abc import ABC
 from abc import abstractmethod
+from collections.abc import AsyncIterator
+
+from amsdal_ml.fileio.base_loader import PLAIN_TEXT
+from amsdal_ml.fileio.base_loader import FileAttachment
 
 
 class ModelError(Exception):
@@ -20,31 +26,62 @@ class ModelAPIError(ModelError):
 
 class MLModel(ABC):
     @abstractmethod
-    def setup(self):
+    def setup(self) -> None:
         """Initialize any clients or resources needed before inference."""
-        pass
+        raise NotImplementedError
 
     @abstractmethod
-    def teardown(self):
+    def teardown(self) -> None:
         """Clean up resources after use."""
-        pass
+        raise NotImplementedError
+
+    def supported_attachments(self) -> set[str]:
+        """Return a set of universal attachment kinds, e.g. {PLAIN_TEXT, FILE_ID}."""
+        return {PLAIN_TEXT}
 
     @abstractmethod
-    def invoke(self, prompt: str) -> str:
+    def invoke(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ) -> str:
         """Run synchronous inference with the model."""
-        pass
+        raise NotImplementedError
 
     @abstractmethod
-    async def ainvoke(self, prompt: str) -> str:
+    async def ainvoke(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ) -> str:
         """Run asynchronous inference with the model."""
-        pass
+        raise NotImplementedError
 
     @abstractmethod
-    def stream(self, prompt: str):
+    def stream(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ):
         """Stream synchronous inference results from the model."""
-        pass
+        raise NotImplementedError
 
     @abstractmethod
-    async def astream(self, prompt: str):
-        """Stream asynchronous inference results from the model."""
-        pass
+    def astream(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ) -> AsyncIterator[str]:
+        """
+        Stream asynchronous inference results as an async generator.
+
+        Subclasses should implement this like:
+
+            async def astream(... ) -> AsyncIterator[str]:
+                yield "chunk"
+        """
+        raise NotImplementedError

amsdal_ml/ml_models/openai_model.py

@@ -2,12 +2,21 @@ from __future__ import annotations
 
 import asyncio
 import os
+from collections.abc import AsyncIterator
+from collections.abc import Iterator
+from typing import Any
 from typing import Optional
+from typing import cast
 
 import openai
 from openai import AsyncOpenAI
+from openai import AsyncStream
 from openai import OpenAI
+from openai import Stream
 
+from amsdal_ml.fileio.base_loader import FILE_ID
+from amsdal_ml.fileio.base_loader import PLAIN_TEXT
+from amsdal_ml.fileio.base_loader import FileAttachment
 from amsdal_ml.ml_config import ml_config
 from amsdal_ml.ml_models.models import MLModel
 from amsdal_ml.ml_models.models import ModelAPIError
@@ -17,13 +26,110 @@ from amsdal_ml.ml_models.models import ModelRateLimitError
 
 
 class OpenAIModel(MLModel):
-    def __init__(self):
+    """OpenAI LLM wrapper using a single Responses API pathway for all modes."""
+
+    def __init__(self) -> None:
         self.client: Optional[OpenAI | AsyncOpenAI] = None
         self.async_mode: bool = bool(ml_config.async_mode)
         self.model_name: str = ml_config.llm_model_name
         self.temperature: float = ml_config.llm_temperature
         self._api_key: Optional[str] = None
 
+    # ---------- Public sync API ----------
+    def invoke(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ) -> str:
+        if self.async_mode:
+            msg = "Async mode is enabled. Use 'ainvoke' instead."
+            raise RuntimeError(msg)
+        if not isinstance(self.client, OpenAI):
+            msg = "Sync client is not initialized. Call setup() first."
+            raise RuntimeError(msg)
+
+        atts = self._validate_attachments(attachments)
+        if self._has_file_ids(atts):
+            input_content = self._build_input_content(prompt, atts)
+            return self._call_responses(input_content)
+
+        final_prompt = self._merge_plain_text(prompt, atts)
+        return self._call_chat(final_prompt)
+
+    def stream(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ) -> Iterator[str]:
+        if self.async_mode:
+            msg = "Async mode is enabled. Use 'astream' instead."
+            raise RuntimeError(msg)
+        if not isinstance(self.client, OpenAI):
+            msg = "Sync client is not initialized. Call setup() first."
+            raise RuntimeError(msg)
+
+        atts = self._validate_attachments(attachments)
+        if self._has_file_ids(atts):
+            input_content = self._build_input_content(prompt, atts)
+            for chunk in self._call_responses_stream(input_content):
+                yield chunk
+            return
+
+        final_prompt = self._merge_plain_text(prompt, atts)
+        for chunk in self._call_chat_stream(final_prompt):
+            yield chunk
+
+    # ---------- Public async API ----------
+    async def ainvoke(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ) -> str:
+        if not self.async_mode:
+            msg = "Async mode is disabled. Use 'invoke' instead."
+            raise RuntimeError(msg)
+        self._ensure_async_client()
+        if not isinstance(self.client, AsyncOpenAI):
+            msg = "Async client is not initialized. Call setup() first."
+            raise RuntimeError(msg)
+
+        atts = self._validate_attachments(attachments)
+        if self._has_file_ids(atts):
+            input_content = self._build_input_content(prompt, atts)
+            return await self._acall_responses(input_content)
+
+        final_prompt = self._merge_plain_text(prompt, atts)
+        return await self._acall_chat(final_prompt)
+
+    async def astream(
+        self,
+        prompt: str,
+        *,
+        attachments: list[FileAttachment] | None = None,
+    ) -> AsyncIterator[str]:
+        if not self.async_mode:
+            msg = "Async mode is disabled. Use 'stream' instead."
+            raise RuntimeError(msg)
+        self._ensure_async_client()
+        if not isinstance(self.client, AsyncOpenAI):
+            msg = "Async client is not initialized. Call setup() first."
+            raise RuntimeError(msg)
+
+        atts = self._validate_attachments(attachments)
+        if self._has_file_ids(atts):
+            input_content = self._build_input_content(prompt, atts)
+            async for chunk in self._acall_responses_stream(input_content):
+                yield chunk
+            return
+
+        final_prompt = self._merge_plain_text(prompt, atts)
+        async for chunk in self._acall_chat_stream(final_prompt):
+            yield chunk
+
+    # ---------- lifecycle ----------
     def setup(self) -> None:
         api_key = os.getenv("OPENAI_API_KEY") or ml_config.resolved_openai_key
         if not api_key:
@@ -36,6 +142,7 @@ class OpenAIModel(MLModel):
 
         try:
             if self.async_mode:
+                # Only create async client if loop is running; otherwise defer.
                 try:
                     asyncio.get_running_loop()
                     self._ensure_async_client()
@@ -43,27 +150,88 @@ class OpenAIModel(MLModel):
                     self.client = None
             else:
                 self.client = OpenAI(api_key=self._api_key)
-        except Exception as e:
+        except Exception as e:  # pragma: no cover
             raise self._map_openai_error(e) from e
 
     def _ensure_async_client(self) -> None:
         if self.client is None:
             try:
                 self.client = AsyncOpenAI(api_key=self._api_key)
-            except Exception as e:
+            except Exception as e:  # pragma: no cover
                 raise self._map_openai_error(e) from e
 
     def teardown(self) -> None:
         self.client = None
 
+    def _require_sync_client(self) -> OpenAI:
+        if not isinstance(self.client, OpenAI):
+            msg = "Sync client is not initialized. Call setup() first."
+            raise RuntimeError(msg)
+        return self.client
+
+    def _require_async_client(self) -> AsyncOpenAI:
+        if not isinstance(self.client, AsyncOpenAI):
+            msg = "Async client is not initialized. Call setup() first."
+            raise RuntimeError(msg)
+        return self.client
+
+    # ---------- attachments ----------
+    def supported_attachments(self) -> set[str]:
+        # Universal kinds supported by this model
+        return {PLAIN_TEXT, FILE_ID}
+
+    def _validate_attachments(
+        self, attachments: list[FileAttachment] | None
+    ) -> list[FileAttachment]:
+        atts = attachments or []
+        kinds = {a.type for a in atts}
+        unsupported = kinds - self.supported_attachments()
+        if unsupported:
+            msg = (
+                f"{self.__class__.__name__} does not support attachments: "
+                f"{', '.join(sorted(unsupported))}"
+            )
+            raise ModelAPIError(msg)
+
+        foreign = [
+            a for a in atts if a.type == FILE_ID and (a.metadata or {}).get("provider") != "openai"
+        ]
+        if foreign:
+            provs = {(a.metadata or {}).get("provider", "unknown") for a in foreign}
+            msg = (
+                f"{self.__class__.__name__} only supports FILE_ID with provider='openai'. "
+                f"Got providers: {', '.join(sorted(provs))}"
+            )
+            raise ModelAPIError(msg)
+
+        return atts
+
+    @staticmethod
+    def _has_file_ids(atts: list[FileAttachment]) -> bool:
+        return any(a.type == FILE_ID for a in atts)
+
+    def _build_input_content(self, prompt: str, atts: list[FileAttachment]) -> list[dict[str, Any]]:
+        parts: list[dict[str, Any]] = [{"type": "input_text", "text": prompt}]
+        for a in atts:
+            if a.type == PLAIN_TEXT:
+                parts.append({"type": "input_text", "text": str(a.content)})
+            elif a.type == FILE_ID:
+                parts.append({"type": "input_file", "file_id": str(a.content)})
+        return [{"role": "user", "content": parts}]
+
+    def _merge_plain_text(self, prompt: str, atts: list[FileAttachment]) -> str:
+        extras = [str(a.content) for a in atts if a.type == PLAIN_TEXT]
+        if not extras:
+            return prompt
+        return f"{prompt}\n\n[ATTACHMENTS]\n" + "\n\n".join(extras)
+
+    # ---------- error mapping ----------
     @staticmethod
     def _map_openai_error(err: Exception) -> ModelError:
         if isinstance(err, openai.RateLimitError):
             return ModelRateLimitError(str(err))
-
         if isinstance(err, openai.APIConnectionError):
             return ModelConnectionError(str(err))
-
         if isinstance(err, openai.APIStatusError):
             status = getattr(err, "status_code", None)
             resp = getattr(err, "response", None)
@@ -72,26 +240,16 @@ class OpenAIModel(MLModel):
                 payload_repr = resp.json() if resp is not None else None
             except Exception:
                 payload_repr = None
-            msg = f"OpenAI API status error ({status}). payload={payload_repr!r}"
-            return ModelAPIError(msg)
-
+            return ModelAPIError(f"OpenAI API status error ({status}). payload={payload_repr!r}")
         if isinstance(err, openai.APIError):
             return ModelAPIError(str(err))
-
         return ModelAPIError(str(err))
 
-    # ---------- Sync ----------
-    def invoke(self, prompt: str) -> str:
-        if self.async_mode:
-            msg = "Async mode is enabled. Use 'ainvoke' instead."
-            raise RuntimeError(msg)
-
-        if not isinstance(self.client, OpenAI):
-            msg = "Sync client is not initialized. Call setup() first."
-            raise RuntimeError(msg)
-
+    # ---------- Sync core callers ----------
+    def _call_chat(self, prompt: str) -> str:
+        client = self._require_sync_client()
         try:
-            resp = self.client.chat.completions.create(
+            resp = client.chat.completions.create(
                 model=self.model_name,
                 messages=[{"role": "user", "content": prompt}],
                 temperature=self.temperature,
@@ -100,17 +258,10 @@ class OpenAIModel(MLModel):
         except Exception as e:
             raise self._map_openai_error(e) from e
 
-    def stream(self, prompt: str):
-        if self.async_mode:
-            msg = "Async mode is enabled. Use 'astream' instead."
-            raise RuntimeError(msg)
-
-        if not isinstance(self.client, OpenAI):
-            msg = "Sync client is not initialized. Call setup() first."
-            raise RuntimeError(msg)
-
+    def _call_chat_stream(self, prompt: str) -> Iterator[str]:
+        client = self._require_sync_client()
         try:
-            stream = self.client.chat.completions.create(
+            stream = client.chat.completions.create(
                 model=self.model_name,
                 messages=[{"role": "user", "content": prompt}],
                 temperature=self.temperature,
@@ -123,18 +274,43 @@ class OpenAIModel(MLModel):
         except Exception as e:
             raise self._map_openai_error(e) from e
 
-    # ---------- Async ----------
-    async def ainvoke(self, prompt: str) -> str:
-        if not self.async_mode:
-            msg = "Async mode is disabled. Use 'invoke' instead."
-            raise RuntimeError(msg)
+    def _call_responses(self, input_content: list[dict[str, Any]]) -> str:
+        client = self._require_sync_client()
+        try:
+            resp: Any = client.responses.create(
+                model=self.model_name,
+                input=cast(Any, input_content),
+                temperature=self.temperature,
+            )
+            return (getattr(resp, "output_text", None) or "").strip()
+        except Exception as e:
+            raise self._map_openai_error(e) from e
 
-        self._ensure_async_client()
-        if not isinstance(self.client, AsyncOpenAI):
-            msg = "Async client is not initialized. Call setup() first."
-            raise RuntimeError(msg)
+    def _call_responses_stream(self, input_content: list[dict[str, Any]]) -> Iterator[str]:
+        client = self._require_sync_client()
+        try:
+            stream_or_resp = client.responses.create(
+                model=self.model_name,
+                input=cast(Any, input_content),
+                temperature=self.temperature,
+                stream=True,
+            )
+            if isinstance(stream_or_resp, Stream):
+                for ev in stream_or_resp:
+                    delta = getattr(getattr(ev, "delta", None), "content", None)
+                    if delta:
+                        yield delta
+            else:
+                text = (getattr(stream_or_resp, "output_text", None) or "").strip()
+                if text:
+                    yield text
+        except Exception as e:
+            raise self._map_openai_error(e) from e
 
-        client = self.client
+    # ---------- Async core callers ----------
+    async def _acall_chat(self, prompt: str) -> str:
+        client = self._require_async_client()
+        print("acall_chat:", prompt)  # noqa: T201
         try:
             resp = await client.chat.completions.create(
                 model=self.model_name,
@@ -145,17 +321,8 @@ class OpenAIModel(MLModel):
         except Exception as e:
             raise self._map_openai_error(e) from e
 
-    async def astream(self, prompt: str):
-        if not self.async_mode:
-            msg = "Async mode is disabled. Use 'stream' instead."
-            raise RuntimeError(msg)
-
-        self._ensure_async_client()
-        if not isinstance(self.client, AsyncOpenAI):
-            msg = "Async client is not initialized. Call setup() first."
-            raise RuntimeError(msg)
-
-        client = self.client
+    async def _acall_chat_stream(self, prompt: str) -> AsyncIterator[str]:
+        client = self._require_async_client()
         try:
             stream = await client.chat.completions.create(
                 model=self.model_name,
@@ -169,3 +336,36 @@ class OpenAIModel(MLModel):
                     yield delta.content
         except Exception as e:
             raise self._map_openai_error(e) from e
+
+    async def _acall_responses(self, input_content: list[dict[str, Any]]) -> str:
+        client = self._require_async_client()
+        try:
+            resp: Any = await client.responses.create(
+                model=self.model_name,
+                input=cast(Any, input_content),
+                temperature=self.temperature,
+            )
+            return (getattr(resp, "output_text", None) or "").strip()
+        except Exception as e:
+            raise self._map_openai_error(e) from e
+
+    async def _acall_responses_stream(self, input_content: list[dict[str, Any]]) -> AsyncIterator[str]:
+        client = self._require_async_client()
+        try:
+            stream_or_resp = await client.responses.create(
+                model=self.model_name,
+                input=cast(Any, input_content),
+                temperature=self.temperature,
+                stream=True,
+            )
+            if isinstance(stream_or_resp, AsyncStream):
+                async for ev in stream_or_resp:
+                    delta = getattr(getattr(ev, "delta", None), "content", None)
+                    if delta:
+                        yield delta
+            else:
+                text = (getattr(stream_or_resp, "output_text", None) or "").strip()
+                if text:
+                    yield text
+        except Exception as e:
+            raise self._map_openai_error(e) from e

amsdal_ml/ml_retrievers/default_retriever.py

@@ -53,15 +53,15 @@ class DefaultRetriever(MLRetriever, ABC):
         )
 
         pre = max(k * 5, 100)
-        rows = list(qs.execute())[:pre]
+        rows = list(qs[:pre].execute())
 
         rows = self._filter_rows_by_tags(rows, include_tags, exclude_tags)
         rows = rows[:k]
 
         return [
             RetrievalChunk(
-                object_class=r.object_class,
-                object_id=r.object_id,
+                object_class=r.data_object_class,
+                object_id=r.data_object_id,
                 chunk_index=r.chunk_index,
                 raw_text=(r.raw_text or '').strip(),
                 distance=float(getattr(r, 'distance', math.inf)),
@@ -94,8 +94,8 @@ class DefaultRetriever(MLRetriever, ABC):
 
         return [
             RetrievalChunk(
-                object_class=r.object_class,
-                object_id=r.object_id,
+                object_class=r.data_object_class,
+                object_id=r.data_object_id,
                 chunk_index=r.chunk_index,
                 raw_text=(r.raw_text or '').strip(),
                 distance=float(getattr(r, 'distance', math.inf)),

amsdal_ml/models/embedding_model.py

@@ -10,8 +10,8 @@ class EmbeddingModel(Model):
     __module_type__ = ModuleType.CONTRIB
     __table_name__ = "embedding_model"
 
-    object_class: str = Field(..., title="Linked object class")
-    object_id: str = Field(..., title="Linked object ID")
+    data_object_class: str = Field(..., title="Linked object class")
+    data_object_id: str = Field(..., title="Linked object ID")
 
     chunk_index: int = Field(..., title="Chunk index")
     raw_text: str = Field(..., title="Raw text used for embedding")

{amsdal_ml-0.1.0.dist-info → amsdal_ml-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amsdal_ml
-Version: 0.1.0
+Version: 0.1.2
 Summary: amsdal_ml plugin for AMSDAL Framework
 Requires-Python: >=3.11
 Requires-Dist: aiohttp==3.12.15

{amsdal_ml-0.1.0.dist-info → amsdal_ml-0.1.2.dist-info}/RECORD

@@ -1,35 +1,39 @@
 amsdal_ml/Third-Party Materials - AMSDAL Dependencies - License Notices.md,sha256=0A3jjw91I-NaTHXCw8IQiKUdFJgVavhgHaFX4Nag4jk,81658
-amsdal_ml/__about__.py,sha256=IMjkMO3twhQzluVTo8Z6rE7Eg-9U79_LGKMcsWLKBkY,22
+amsdal_ml/__about__.py,sha256=mdp2CftfqYbdKtP-eWv1z7rAUycYv6X1ntXSMUf8Kss,22
 amsdal_ml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 amsdal_ml/app.py,sha256=yq_XIstjXSKplsjHLn9Jb65zXx4HOdjPKVlbz5FT9ec,715
 amsdal_ml/ml_config.py,sha256=UONMVG2RbKVbaYF-GdlhRQbm8flp52GxBzfqdzuLZ5w,1788
 amsdal_ml/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 amsdal_ml/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-amsdal_ml/agents/agent.py,sha256=Eb_jCSIZy2tX2dAPqa65iUd4aE26g8V3G76gAbiTub0,1123
-amsdal_ml/agents/default_qa_agent.py,sha256=8Y02ovsWKRVBNywRziBYtPKBQjJL0lKL5TCrJRIruWY,13375
-amsdal_ml/agents/retriever_tool.py,sha256=EzmjyN4CaRGue5DHsEQ0GbxVohx6XEhvOtPl9DZkXaU,1276
+amsdal_ml/agents/agent.py,sha256=L00RTIkopdGnJp_NctEtWRXAgWy1DAn7AEg0rMoXdJw,1514
+amsdal_ml/agents/default_qa_agent.py,sha256=MjrA5XYOKe5PwfSnkoeGmEnC8mP9asRHGHPHd1oPH6g,14017
+amsdal_ml/agents/retriever_tool.py,sha256=SqIGqYi_xMcm_MgLcwdMW2ALzYphkk02KBevH8n-Op0,1850
 amsdal_ml/agents/promts/__init__.py,sha256=3AKR3lrV067CO03XYFDmAKJv0x2oqSTcVeDIqNwoAu0,1571
-amsdal_ml/agents/promts/react_chat.prompt,sha256=vw80QrkwMq-tRWgvWhMQB8NV1KVeo5yZLO-DwH2F96k,927
+amsdal_ml/agents/promts/react_chat.prompt,sha256=EArdA102sSBOWchhub1QoaKws_DVpMqDflc5htBkFKI,1762
+amsdal_ml/fileio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amsdal_ml/fileio/base_loader.py,sha256=rFeClp-ZkSX6Ja1vz1RutlyMqYIGgR48CrtXDWXr4Ns,1866
+amsdal_ml/fileio/openai_loader.py,sha256=4YyxK5pBAnRm55et5yMu6X5OdK2kWTqpuPF1E2-oFZc,2572
 amsdal_ml/mcp_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 amsdal_ml/mcp_client/base.py,sha256=cNuHHCSSND4BkIyhQZ-1mJLPp630wTCtiCQSHnK2zmA,441
 amsdal_ml/mcp_client/http_client.py,sha256=2fFCaubp_cFeyCqN9CP7bVLTp4UIIEhJPq9BVHBf6-w,1719
-amsdal_ml/mcp_client/stdio_client.py,sha256=9dNrFDiQceEFBknfrSCGnZirDRCwwRuNL2eezPz84AM,4988
+amsdal_ml/mcp_client/stdio_client.py,sha256=bYfS2yCeJNl8fxBn6Yerg4RBZKbW2pgcdKiwX-NL6io,5744
 amsdal_ml/mcp_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-amsdal_ml/mcp_server/server_retriever_stdio.py,sha256=1CFZLmB-7mRsNNIxfqzz3-MXZttAE3qZeRkz2l0-kX0,331
+amsdal_ml/mcp_server/server_retriever_stdio.py,sha256=iUQNwWEDZE0OIS9vyTyJp_EOn4kvl9Gn0Okzcq-ymo0,1762
+amsdal_ml/migrations/0000_initial.py,sha256=UeEtqHrCgmTQyGnyV2jC7yt9Ce7Xm0-MyhOQU3rRrs8,1633
 amsdal_ml/ml_ingesting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-amsdal_ml/ml_ingesting/default_ingesting.py,sha256=Hg5D_CjIZJAxH8juw42R9i-OyUlL0qzhbn6R43ETkA4,12839
+amsdal_ml/ml_ingesting/default_ingesting.py,sha256=udVAyUbjeCrsP9pk-VbAH689M3VmBRhOFbl9Que9oK0,12859
 amsdal_ml/ml_ingesting/embedding_data.py,sha256=ZWxhYq8mkFVC3HMM5nEiObgy62X8hLh1McaGegnRUsk,355
 amsdal_ml/ml_ingesting/ingesting.py,sha256=h-GdNCtutO8C75jbLko40CMjHym9Xk_nlMdNYLfBs58,1458
 amsdal_ml/ml_ingesting/openai_ingesting.py,sha256=_2dU2id2a3xR_y0GvZc5LUDw3_wI-wbhEFogEOKF-H0,1421
 amsdal_ml/ml_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-amsdal_ml/ml_models/models.py,sha256=8MZLZygR5AbthJyXQtmV-c6ZD2JQ6RgfkzP1cP2N1kM,1250
-amsdal_ml/ml_models/openai_model.py,sha256=4bk5lZVy_C23iLDvS_VYQ_mdGvDwZ4IjWYrexc3PHTU,6042
+amsdal_ml/ml_models/models.py,sha256=gZzZrjsoAnFc5pPwqqLPNh5RYxwKKaFyNg56NJnsn4w,2286
+amsdal_ml/ml_models/openai_model.py,sha256=yQ6r4K7AOeG3NfWT6pXgjkRPMT0FuQPqFUWeHSwz0u8,14295
 amsdal_ml/ml_retrievers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-amsdal_ml/ml_retrievers/default_retriever.py,sha256=OSvE3LWgy30dua4j5FBIhooGOD90VvK2wcjgvW6FQho,3213
+amsdal_ml/ml_retrievers/default_retriever.py,sha256=ykAzi6gESyG1693nALpPJ9XhKV_We1yrNxbYo1eG748,3233
 amsdal_ml/ml_retrievers/openai_retriever.py,sha256=oY71oPJdFuECWaJL_ByKZFE7HRJ-S6ypRzzJ7XjI7H8,1236
 amsdal_ml/ml_retrievers/retriever.py,sha256=zHvaAOAD6H4IaIaYA_wy2e8tMmGtOnyNsDS2B4dQjBU,1005
 amsdal_ml/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-amsdal_ml/models/embedding_model.py,sha256=26sLxJ1VPbW0ZuY0mQOfHm_ADcKNzxq9_ffJ91SzHg8,764
-amsdal_ml-0.1.0.dist-info/METADATA,sha256=Bvngk7esO1e-zkc8lmOv8IcEGmZdncWyOLRLz-5vIN4,1676
-amsdal_ml-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-amsdal_ml-0.1.0.dist-info/RECORD,,
+amsdal_ml/models/embedding_model.py,sha256=mdMSYHrkSIKHi5mg4HqMaTTiPGqLYtRdRkbEK_trFWw,774
+amsdal_ml-0.1.2.dist-info/METADATA,sha256=N0ZdcQ0_5Wr2qTYxPAQK08_x6QGKyQZZRNURJQCmxiY,1676
+amsdal_ml-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+amsdal_ml-0.1.2.dist-info/RECORD,,