trustgraph-flow 2.7.3__tar.gz → 2.7.5__tar.gz

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-flow
-Version: 2.7.3
+Version: 2.7.5
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
 Author-email: "trustgraph.ai" <security@trustgraph.ai>
 Project-URL: Homepage, https://github.com/trustgraph-ai/trustgraph

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/pyproject.toml

@@ -85,6 +85,7 @@ graph-embeddings-write-pinecone = "trustgraph.storage.graph_embeddings.pinecone:
 graph-embeddings-write-qdrant = "trustgraph.storage.graph_embeddings.qdrant:run"
 graph-embeddings = "trustgraph.embeddings.graph_embeddings:run"
 graph-rag = "trustgraph.retrieval.graph_rag:run"
+image-to-text-openai = "trustgraph.model.image_to_text.openai:run"
 reranker-flashrank = "trustgraph.reranker.flashrank:run"
 kg-extract-agent = "trustgraph.extract.kg.agent:run"
 kg-extract-definitions = "trustgraph.extract.kg.definitions:run"

trustgraph_flow-2.7.5/trustgraph/flow_version.py

@@ -0,0 +1 @@
+__version__ = "2.7.5"

trustgraph_flow-2.7.5/trustgraph/gateway/dispatch/image_to_text.py

@@ -0,0 +1,32 @@
+
+from ... schema import ImageToTextRequest, ImageToTextResponse
+from ... messaging import TranslatorRegistry
+
+from . requestor import ServiceRequestor
+
+class ImageToTextRequestor(ServiceRequestor):
+    def __init__(
+            self, backend, request_queue, response_queue, timeout,
+            consumer, subscriber,
+    ):
+
+        super(ImageToTextRequestor, self).__init__(
+            backend=backend,
+            request_queue=request_queue,
+            response_queue=response_queue,
+            request_schema=ImageToTextRequest,
+            response_schema=ImageToTextResponse,
+            subscription = subscriber,
+            consumer_name = consumer,
+            timeout=timeout,
+        )
+
+        self.request_translator = TranslatorRegistry.get_request_translator("image-to-text")
+        self.response_translator = TranslatorRegistry.get_response_translator("image-to-text")
+
+    def to_request(self, body):
+        return self.request_translator.decode(body)
+
+    def from_response(self, message):
+        return self.response_translator.encode_with_completion(message)
+

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/gateway/dispatch/manager.py

@@ -23,6 +23,7 @@ from . collection_management import CollectionManagementRequestor
 from . embeddings import EmbeddingsRequestor
 from . agent import AgentRequestor
 from . text_completion import TextCompletionRequestor
+from . image_to_text import ImageToTextRequestor
 from . prompt import PromptRequestor
 from . graph_rag import GraphRagRequestor
 from . document_rag import DocumentRagRequestor
@@ -76,6 +77,7 @@ request_response_dispatchers = {
     "row-embeddings": RowEmbeddingsQueryRequestor,
     "sparql": SparqlQueryRequestor,
     "reranker": RerankerRequestor,
+    "image-to-text": ImageToTextRequestor,
 }
 
 system_dispatchers = {

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/gateway/registry.py

@@ -519,6 +519,7 @@ _FLOW_SERVICES = {
     "row-embeddings": "row-embeddings:read",
     "sparql": "sparql:read",
     "reranker": "reranker",
+    "image-to-text": "image-to-text",
 }
 for _kind, _cap in _FLOW_SERVICES.items():
     _register_flow_kind("flow-service", _kind, _cap)

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/iam/service/iam.py

@@ -73,6 +73,7 @@ _READER_CAPS = {
     "llm",
     "embeddings",
     "reranker",
+    "image-to-text",
     "mcp",
     "config:read",
     "flows:read",

trustgraph_flow-2.7.5/trustgraph/model/image_to_text/openai/service.py

@@ -0,0 +1,172 @@
+
+"""
+Simple image-to-text service, describes images using the OpenAI vision
+API.  Input is base64-encoded image, MIME type and prompt, output is
+image description.
+"""
+
+from openai import OpenAI, RateLimitError, InternalServerError
+import os
+import logging
+
+from .... exceptions import TooManyRequests, LlmError
+from .... base import ImageToTextService, ImageDescriptionResult
+
+# Module logger
+logger = logging.getLogger(__name__)
+
+default_ident = "image-to-text"
+
+default_model = 'gpt-5-mini'
+default_max_output = 4096
+default_api_key = os.getenv("OPENAI_TOKEN")
+default_base_url = os.getenv("OPENAI_BASE_URL")
+default_prompt = 'Describe this image'
+
+if default_base_url is None or default_base_url == "":
+    default_base_url = "https://api.openai.com/v1"
+
+class Processor(ImageToTextService):
+
+    def __init__(self, **params):
+
+        model = params.get("model", default_model)
+        api_key = params.get("api_key", default_api_key)
+        base_url = params.get("url", default_base_url)
+        max_output = params.get("max_output", default_max_output)
+
+        if not api_key:
+            api_key = "not-set"
+
+        super(Processor, self).__init__(
+            **params | {
+                "model": model,
+                "max_output": max_output,
+                "base_url": base_url,
+            }
+        )
+
+        self.default_model = model
+        self.max_output = max_output
+
+        if base_url:
+            self.openai = OpenAI(base_url=base_url, api_key=api_key)
+        else:
+            self.openai = OpenAI(api_key=api_key)
+
+        logger.info("OpenAI image-to-text service initialized")
+
+    async def describe_image(
+        self, image, mime_type, prompt, system, model=None,
+    ):
+
+        model_name = model or self.default_model
+
+        logger.debug(f"Using model: {model_name}")
+
+        if not prompt:
+            prompt = default_prompt
+
+        if system:
+            prompt = system + "\n\n" + prompt
+
+        try:
+
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:{mime_type};base64,{image}"
+                            }
+                        }
+                    ]
+                }
+            ]
+
+            resp = self.openai.chat.completions.create(
+                model=model_name,
+                messages=messages,
+                max_completion_tokens=self.max_output,
+            )
+
+            inputtokens = resp.usage.prompt_tokens
+            outputtokens = resp.usage.completion_tokens
+
+            content = resp.choices[0].message.content
+
+            logger.debug(f"Image description: {content}")
+            logger.info(f"Input Tokens: {inputtokens}")
+            logger.info(f"Output Tokens: {outputtokens}")
+
+            resp = ImageDescriptionResult(
+                text = content,
+                in_token = inputtokens,
+                out_token = outputtokens,
+                model = model_name
+            )
+
+            return resp
+
+        except RateLimitError as e:
+            try:
+                body = getattr(e, 'body', {})
+                if isinstance(body, dict):
+                    code = body.get('error', {}).get('code')
+                    if code in ('insufficient_quota', 'invalid_api_key', 'account_deactivated'):
+                        raise RuntimeError(f"OpenAI unrecoverable error: {code} - {body['error'].get('message', '')}")
+            except (ValueError, KeyError, TypeError, AttributeError):
+                pass
+            # Leave rate limit retries to the base handler
+            raise TooManyRequests()
+
+        except InternalServerError:
+            # Treat 503 as a retryable LlmError
+            raise LlmError()
+
+        except Exception as e:
+
+            # Apart from rate limits, treat all exceptions as unrecoverable
+
+            logger.error(f"OpenAI image-to-text exception ({type(e).__name__}): {e}", exc_info=True)
+            raise e
+
+    @staticmethod
+    def add_args(parser):
+
+        ImageToTextService.add_args(parser)
+
+        parser.add_argument(
+            '-m', '--model',
+            default=default_model,
+            help=f'Vision model (default: {default_model})'
+        )
+
+        parser.add_argument(
+            '-k', '--api-key',
+            default=default_api_key,
+            help=f'OpenAI API key'
+        )
+
+        parser.add_argument(
+            '-u', '--url',
+            default=default_base_url,
+            help=f'OpenAI service base URL'
+        )
+
+        parser.add_argument(
+            '-x', '--max-output',
+            type=int,
+            default=default_max_output,
+            help=f'Vision model max output tokens (default: {default_max_output})'
+        )
+
+def run():
+
+    Processor.launch(default_ident, __doc__)

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/model/text_completion/azure/llm.py

@@ -55,7 +55,10 @@ class Processor(LlmService):
         self.max_output = max_output
         self.default_model = model
 
-    def build_prompt(self, system, content, temperature=None, stream=False, model=None):
+    def build_prompt(
+        self, system, content, temperature=None, stream=False,
+        model=None, response_format=None, schema=None,
+    ):
         # Use provided temperature or fall back to default
         effective_temperature = temperature if temperature is not None else self.temperature
         model_name = model or self.default_model
@@ -79,6 +82,17 @@ class Processor(LlmService):
             data["stream"] = True
             data["stream_options"] = {"include_usage": True}
 
+        if response_format == "json" and schema is not None:
+            data["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "response",
+                    "schema": schema,
+                    "strict": True,
+                },
+            }
+            logger.debug("Structured output enabled")
+
         body = json.dumps(data)
 
         return body
@@ -109,7 +123,10 @@ class Processor(LlmService):
 
         return result
 
-    async def generate_content(self, system, prompt, model=None, temperature=None):
+    async def generate_content(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
 
         # Use provided model or fall back to default
         model_name = model or self.default_model
@@ -125,7 +142,9 @@ class Processor(LlmService):
                 system,
                 prompt,
                 effective_temperature,
-                model=model_name
+                model=model_name,
+                response_format=response_format,
+                schema=schema,
             )
 
             response = self.call_llm(prompt)
@@ -169,7 +188,10 @@ class Processor(LlmService):
         """Azure serverless endpoints support streaming"""
         return True
 
-    async def generate_content_stream(self, system, prompt, model=None, temperature=None):
+    async def generate_content_stream(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
         """Stream content generation from Azure serverless endpoint"""
         model_name = model or self.default_model
         effective_temperature = temperature if temperature is not None else self.temperature
@@ -178,7 +200,11 @@ class Processor(LlmService):
         logger.debug(f"Using temperature: {effective_temperature}")
 
         try:
-            body = self.build_prompt(system, prompt, effective_temperature, stream=True, model=model_name)
+            body = self.build_prompt(
+                system, prompt, effective_temperature, stream=True,
+                model=model_name, response_format=response_format,
+                schema=schema,
+            )
 
             url = self.endpoint
             api_key = self.token

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/model/text_completion/azure_openai/llm.py

@@ -62,7 +62,10 @@ class Processor(LlmService):
             azure_endpoint = endpoint,
         )
 
-    async def generate_content(self, system, prompt, model=None, temperature=None):
+    async def generate_content(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
 
         # Use provided model or fall back to default
         model_name = model or self.default_model
@@ -76,6 +79,18 @@ class Processor(LlmService):
 
         try:
 
+            kwargs = {}
+            if response_format == "json" and schema is not None:
+                kwargs["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "response",
+                        "schema": schema,
+                        "strict": True,
+                    },
+                }
+                logger.debug("Structured output enabled")
+
             resp = self.openai.chat.completions.create(
                 model=model_name,
                 messages=[
@@ -92,6 +107,7 @@ class Processor(LlmService):
                 temperature=effective_temperature,
                 max_completion_tokens=self.max_output,
                 top_p=1,
+                **kwargs,
             )
 
             inputtokens = resp.usage.prompt_tokens
@@ -129,7 +145,10 @@ class Processor(LlmService):
         """Azure OpenAI supports streaming"""
         return True
 
-    async def generate_content_stream(self, system, prompt, model=None, temperature=None):
+    async def generate_content_stream(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
         """
         Stream content generation from Azure OpenAI.
         Yields LlmChunk objects with is_final=True on the last chunk.

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/model/text_completion/claude/llm.py

@@ -48,7 +48,10 @@ class Processor(LlmService):
 
         logger.info("Claude LLM service initialized")
 
-    async def generate_content(self, system, prompt, model=None, temperature=None):
+    async def generate_content(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
 
         # Use provided model or fall back to default
         model_name = model or self.default_model
@@ -60,11 +63,27 @@ class Processor(LlmService):
 
         try:
 
+            kwargs = {}
+            use_tool_extract = False
+
+            if response_format == "json" and schema is not None:
+                kwargs["tools"] = [{
+                    "name": "structured_response",
+                    "description": "Return the structured response",
+                    "input_schema": schema,
+                }]
+                kwargs["tool_choice"] = {
+                    "type": "tool",
+                    "name": "structured_response",
+                }
+                use_tool_extract = True
+                logger.debug("Structured output enabled (tool-use)")
+
             response = message = self.claude.messages.create(
                 model=model_name,
                 max_tokens=self.max_output,
                 temperature=effective_temperature,
-                system = system,
+                system=system,
                 messages=[
                     {
                         "role": "user",
@@ -75,10 +94,22 @@ class Processor(LlmService):
                             }
                         ]
                     }
-                ]
+                ],
+                **kwargs,
             )
 
-            resp = response.content[0].text
+            if use_tool_extract:
+                import json
+                tool_block = next(
+                    (b for b in response.content if b.type == "tool_use"),
+                    None,
+                )
+                if tool_block:
+                    resp = json.dumps(tool_block.input)
+                else:
+                    resp = response.content[0].text
+            else:
+                resp = response.content[0].text
             inputtokens = response.usage.input_tokens
             outputtokens = response.usage.output_tokens
             logger.debug(f"LLM response: {resp}")
@@ -110,7 +141,10 @@ class Processor(LlmService):
         """Claude/Anthropic supports streaming"""
         return True
 
-    async def generate_content_stream(self, system, prompt, model=None, temperature=None):
+    async def generate_content_stream(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
         """Stream content generation from Claude"""
         model_name = model or self.default_model
         effective_temperature = temperature if temperature is not None else self.temperature

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/model/text_completion/cohere/llm.py

@@ -46,7 +46,10 @@ class Processor(LlmService):
 
         logger.info("Cohere LLM service initialized")
 
-    async def generate_content(self, system, prompt, model=None, temperature=None):
+    async def generate_content(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
 
         # Use provided model or fall back to default
         model_name = model or self.default_model
@@ -104,7 +107,10 @@ class Processor(LlmService):
         """Cohere supports streaming"""
         return True
 
-    async def generate_content_stream(self, system, prompt, model=None, temperature=None):
+    async def generate_content_stream(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
         """Stream content generation from Cohere"""
         model_name = model or self.default_model
         effective_temperature = temperature if temperature is not None else self.temperature

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/model/text_completion/llamafile/llm.py

@@ -50,7 +50,10 @@ class Processor(LlmService):
 
         logger.info("Llamafile LLM service initialized")
 
-    async def generate_content(self, system, prompt, model=None, temperature=None):
+    async def generate_content(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
 
         # Use provided model or fall back to default
         model_name = model or self.default_model
@@ -64,6 +67,18 @@ class Processor(LlmService):
 
         try:
 
+            if response_format == "json" and schema is not None:
+                fmt = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "response",
+                        "schema": schema,
+                    },
+                }
+                logger.debug("Structured output enabled")
+            else:
+                fmt = {"type": "text"}
+
             resp = self.openai.chat.completions.create(
                 model=model_name,
                 messages=[
@@ -74,9 +89,7 @@ class Processor(LlmService):
                 top_p=1,
                 frequency_penalty=0,
                 presence_penalty=0,
-                response_format={
-                    "type": "text"
-                }
+                response_format=fmt,
             )
 
             inputtokens = resp.usage.prompt_tokens
@@ -106,7 +119,10 @@ class Processor(LlmService):
         """LlamaFile supports streaming"""
         return True
 
-    async def generate_content_stream(self, system, prompt, model=None, temperature=None):
+    async def generate_content_stream(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
         """Stream content generation from LlamaFile"""
         model_name = model or self.default_model
         effective_temperature = temperature if temperature is not None else self.temperature
@@ -117,6 +133,18 @@ class Processor(LlmService):
         prompt = system + "\n\n" + prompt
 
         try:
+            if response_format == "json" and schema is not None:
+                fmt = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "response",
+                        "schema": schema,
+                    },
+                }
+                logger.debug("Structured output enabled (streaming)")
+            else:
+                fmt = {"type": "text"}
+
             response = self.openai.chat.completions.create(
                 model=model_name,
                 messages=[{"role": "user", "content": prompt}],
@@ -125,7 +153,7 @@ class Processor(LlmService):
                 top_p=1,
                 frequency_penalty=0,
                 presence_penalty=0,
-                response_format={"type": "text"},
+                response_format=fmt,
                 stream=True,
                 stream_options={"include_usage": True}
             )

{trustgraph_flow-2.7.3 → trustgraph_flow-2.7.5}/trustgraph/model/text_completion/lmstudio/llm.py

@@ -50,7 +50,10 @@ class Processor(LlmService):
 
         logger.info("LMStudio LLM service initialized")
 
-    async def generate_content(self, system, prompt, model=None, temperature=None):
+    async def generate_content(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
 
         # Use provided model or fall back to default
         model_name = model or self.default_model
@@ -66,6 +69,18 @@ class Processor(LlmService):
 
             logger.debug(f"Prompt: {prompt}")
 
+            if response_format == "json" and schema is not None:
+                fmt = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "response",
+                        "schema": schema,
+                    },
+                }
+                logger.debug("Structured output enabled")
+            else:
+                fmt = {"type": "text"}
+
             resp = self.openai.chat.completions.create(
                 model=model_name,
                 messages=[
@@ -76,9 +91,7 @@ class Processor(LlmService):
                 top_p=1,
                 frequency_penalty=0,
                 presence_penalty=0,
-                response_format={
-                    "type": "text"
-                }
+                response_format=fmt,
             )
 
             logger.debug(f"Full response: {resp}")
@@ -110,7 +123,10 @@ class Processor(LlmService):
         """LM Studio supports streaming"""
         return True
 
-    async def generate_content_stream(self, system, prompt, model=None, temperature=None):
+    async def generate_content_stream(
+        self, system, prompt, model=None, temperature=None,
+        response_format=None, schema=None,
+    ):
         """Stream content generation from LM Studio"""
         model_name = model or self.default_model
         effective_temperature = temperature if temperature is not None else self.temperature
@@ -121,6 +137,18 @@ class Processor(LlmService):
         prompt = system + "\n\n" + prompt
 
         try:
+            if response_format == "json" and schema is not None:
+                fmt = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "response",
+                        "schema": schema,
+                    },
+                }
+                logger.debug("Structured output enabled (streaming)")
+            else:
+                fmt = {"type": "text"}
+
             response = self.openai.chat.completions.create(
                 model=model_name,
                 messages=[{"role": "user", "content": prompt}],
@@ -129,7 +157,7 @@ class Processor(LlmService):
                 top_p=1,
                 frequency_penalty=0,
                 presence_penalty=0,
-                response_format={"type": "text"},
+                response_format=fmt,
                 stream=True,
                 stream_options={"include_usage": True}
             )