evalforge-runtime 0.2.0__tar.gz → 0.2.2__tar.gz

{evalforge_runtime-0.2.0 → evalforge_runtime-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evalforge-runtime
-Version: 0.2.0
+Version: 0.2.2
 Summary: Runtime engine for EvalForge generated applications
 Project-URL: Homepage, https://github.com/JannisConen/evalforge-runtime
 Project-URL: Repository, https://github.com/JannisConen/evalforge-runtime

evalforge_runtime-0.2.2/docs/decisions/001-file-forwarding-in-process-chains.md

@@ -0,0 +1,34 @@
+# ADR 001: File Forwarding in Process Chains
+
+## Context
+
+When one process calls another via `process.call`, the field mappings can reference files from the original trigger input (e.g. `input.email`). By the time the after step runs, `context["input"]` contains the already-resolved file dict — i.e. what came out of `resolve_file_refs()`. This dict has `content` (decoded text) and `path` (local filesystem path) added to it.
+
+Naively forwarding this resolved dict over HTTP to the downstream process causes two problems:
+
+1. **Encoding errors on servers with ASCII locale** (`LANG=C`, common in Docker). The decoded content may contain non-ASCII characters (e.g. German `ö`, `ü`). Even though httpx uses `ensure_ascii=False`, the Python process itself or logging handlers may have an ASCII default encoding, causing `UnicodeEncodeError`.
+
+2. **Inflated payload size.** The decoded email text is duplicated in the HTTP body, even though the downstream process would re-read it from storage anyway.
+
+## Decision
+
+**Send clean FileRefs across process boundaries, never resolved content.**
+
+Two changes enforce this:
+
+1. **`files.py` — preserve `type` and `key` on resolved dicts.** After resolving a FileRef, the result dict retains `type: "local"` and `key: <storage key>`. This makes the resolved dict a valid FileRef so it can be re-resolved by a downstream process.
+
+2. **`process_call.py` — strip `content` and `path` before forwarding.** In `_build_input()`, any value that looks like a local/s3/url FileRef (has `type` and `key`) has its `content` and `path` fields removed before being sent. The downstream process receives only the FileRef metadata and re-resolves the file from shared storage.
+
+## Consequences
+
+- Files must be in shared storage accessible to all processes on the same runtime. This is the case by default (single runtime, `LocalStorage`). For multi-host deployments, an S3 or shared filesystem storage backend is required anyway.
+- Downstream processes always get fresh file resolution (re-read from storage, re-decoded), which is correct.
+- The `content` field is never available in `context["input"]` inside after.py — only the raw file dict with FileRef fields. This is intentional; only execution.py needs `content`.
+
+## Open Questions / TODOs
+
+- The connector `file` → InputSchema field name aliasing (`_apply_connector_file_aliases` in `pipeline.py`) is a runtime workaround for a mismatch between connector output keys and generated InputSchema field names. A cleaner long-term solution would be to either:
+  - Teach the agent (via `trigger-action-registry.md`) that email triggers always expose the `.eml` file at `input.file`, and have the agent generate field mappings with `input.file` as source.
+  - Standardize connectors to always use the same key (e.g. always `file`), and keep generated InputSchemas consistent.
+  - Current approach: runtime inspects the InputSchema at pipeline entry and adds an alias if a FileInput field with a different name is found and `file` is present in the input dict.

{evalforge_runtime-0.2.0 → evalforge_runtime-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "evalforge-runtime"
-version = "0.2.0"
+version = "0.2.2"
 description = "Runtime engine for EvalForge generated applications"
 readme = "README.md"
 requires-python = ">=3.10"

{evalforge_runtime-0.2.0 → evalforge_runtime-0.2.2}/src/evalforge_runtime/actions/builtins/process_call.py

@@ -10,6 +10,8 @@ import importlib
 import logging
 from typing import Any
 
+import json as _json
+
 import httpx
 
 from evalforge_runtime.actions.base import BaseAction
@@ -137,6 +139,12 @@ class ProcessCallAction(BaseAction):
             if transform_code:
                 value = self._apply_transform(transform_code, value, output)
 
+            # Strip resolved-only fields before forwarding — downstream re-resolves from storage.
+            # Passing large decoded content (e.g. full email text) over HTTP can cause
+            # encoding errors on servers with ASCII locale (LANG=C) and inflates payload size.
+            if isinstance(value, dict) and value.get("type") in ("local", "s3", "url") and value.get("key"):
+                value = {k: v for k, v in value.items() if k not in ("content", "path")}
+
             self._set_path(result, target_path, value)
 
         return result

{evalforge_runtime-0.2.0 → evalforge_runtime-0.2.2}/src/evalforge_runtime/connectors/gmail.py

@@ -447,6 +447,106 @@ class GmailConnector(Connector):
             resp.raise_for_status()
             logger.info("Reply sent via Gmail API (thread=%s)", thread_id)
 
+    # -----------------------------------------------------------------------
+    # Forward
+    # -----------------------------------------------------------------------
+
+    async def forward(self, message_id: str, to: str, body: str = "") -> None:
+        """Forward a message to another recipient."""
+        logger.info("Forwarding message %s to %s", message_id, to)
+        if self._auth_method != "service_account":
+            await self._forward_smtp(message_id, to, body)
+        else:
+            await self._forward_api(message_id, to, body)
+
+    async def _forward_smtp(self, message_id: str, to: str, body: str) -> None:
+        """Forward via SMTP — fetches original via IMAP and re-sends."""
+        def _do_forward() -> None:
+            mail = imaplib.IMAP4_SSL("imap.gmail.com")
+            mail.login(self._mailbox, self.secrets["GMAIL_APP_PASSWORD"])
+            mail.select("INBOX")
+
+            _, msg_data = mail.fetch(message_id.encode(), "(RFC822)")
+            if not msg_data or not msg_data[0] or not isinstance(msg_data[0], tuple):
+                raise ValueError(f"Could not fetch original message {message_id}")
+
+            original = email_lib.message_from_bytes(msg_data[0][1])
+            subject = str(original.get("Subject", ""))
+            fwd_subject = subject if subject.lower().startswith("fwd:") else f"Fwd: {subject}"
+
+            import email.mime.multipart
+            fwd = email.mime.multipart.MIMEMultipart()
+            fwd["From"] = self._mailbox
+            fwd["To"] = to
+            fwd["Subject"] = fwd_subject
+
+            if body:
+                fwd.attach(email.mime.text.MIMEText(body, "html"))
+
+            # Attach original as message/rfc822
+            import email.mime.message
+            attached = email.mime.message.MIMEMessage(original)
+            fwd.attach(attached)
+
+            with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
+                server.login(self._mailbox, self.secrets["GMAIL_APP_PASSWORD"])
+                server.send_message(fwd)
+            logger.info("Message %s forwarded via SMTP to %s", message_id, to)
+            mail.logout()
+
+        await asyncio.to_thread(_do_forward)
+
+    async def _forward_api(self, message_id: str, to: str, body: str) -> None:
+        """Forward via Gmail API — fetches raw message and re-sends."""
+        token = await self._acquire_token()
+
+        async with httpx.AsyncClient() as client:
+            # Fetch original metadata for subject
+            resp = await client.get(
+                f"https://gmail.googleapis.com/gmail/v1/users/{self._mailbox}"
+                f"/messages/{message_id}?format=metadata",
+                headers={"Authorization": f"Bearer {token}"},
+            )
+            resp.raise_for_status()
+            msg = resp.json()
+            headers_map = {
+                h["name"].lower(): h["value"]
+                for h in msg.get("payload", {}).get("headers", [])
+            }
+            subject = headers_map.get("subject", "")
+            fwd_subject = subject if subject.lower().startswith("fwd:") else f"Fwd: {subject}"
+
+            # Fetch raw RFC822
+            raw_resp = await client.get(
+                f"https://gmail.googleapis.com/gmail/v1/users/{self._mailbox}"
+                f"/messages/{message_id}?format=raw",
+                headers={"Authorization": f"Bearer {token}"},
+            )
+            raw_resp.raise_for_status()
+            raw_bytes = base64.urlsafe_b64decode(raw_resp.json().get("raw", ""))
+
+        original = email_lib.message_from_bytes(raw_bytes)
+
+        import email.mime.multipart
+        import email.mime.message
+        fwd = email.mime.multipart.MIMEMultipart()
+        fwd["to"] = to
+        fwd["subject"] = fwd_subject
+        if body:
+            fwd.attach(email.mime.text.MIMEText(body, "html"))
+        fwd.attach(email.mime.message.MIMEMessage(original))
+
+        raw_fwd = base64.urlsafe_b64encode(fwd.as_bytes()).decode("utf-8")
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                f"https://gmail.googleapis.com/gmail/v1/users/{self._mailbox}/messages/send",
+                headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
+                json={"raw": raw_fwd},
+            )
+            resp.raise_for_status()
+            logger.info("Message %s forwarded via Gmail API to %s", message_id, to)
+
     # -----------------------------------------------------------------------
     # Move / Mark read
     # -----------------------------------------------------------------------

{evalforge_runtime-0.2.0 → evalforge_runtime-0.2.2}/src/evalforge_runtime/files.py

@@ -206,6 +206,9 @@ async def _resolve_single(
     local_path = str(storage.base_path / local_key)
 
     result: dict[str, Any] = {
+        # Keep type/key so downstream processes can re-resolve this as a FileRef
+        "type": "local",
+        "key": local_key,
         "filename": filename,
         "path": local_path,
         "mimeType": mime_type,