AbstractRuntime 0.4.10__tar.gz → 0.4.11__tar.gz

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.11] - 2026-05-13
+
+### Fixed
+- AbstractCore effect-handler media materialization now preserves artifact `content_type`, media `type`, artifact ids, and safe filename extensions instead of dropping artifact-backed media to bare paths. This keeps generated WAV artifacts valid for downstream transcription nodes.
+- Added explicit MIME extension aliases for common generated media types such as `audio/wav`, `image/png`, and `video/mp4` so platform MIME table differences do not create extensionless temp files.
+
+### Changed
+- Minimum AbstractCore optional dependency floor is now `abstractcore>=2.13.14`.
+
+
 ## [0.4.10] - 2026-05-12
 
 ### Fixed

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractRuntime
-Version: 0.4.10
+Version: 0.4.11
 Summary: AbstractRuntime: a durable graph runner designed to pair with AbstractCore.
 Project-URL: AbstractCore (website), https://www.abstractcore.ai/
 Project-URL: AbstractRuntime (GitHub), https://github.com/lpalbou/abstractruntime
@@ -23,23 +23,23 @@ Requires-Python: >=3.10
 Requires-Dist: abstractmemory>=0.2.6
 Requires-Dist: abstractsemantics>=0.0.3
 Provides-Extra: abstractcore
-Requires-Dist: abstractcore>=2.13.13; extra == 'abstractcore'
+Requires-Dist: abstractcore>=2.13.14; extra == 'abstractcore'
 Provides-Extra: all-apple
-Requires-Dist: abstractcore[all-apple]>=2.13.13; extra == 'all-apple'
+Requires-Dist: abstractcore[all-apple]>=2.13.14; extra == 'all-apple'
 Provides-Extra: all-gpu
-Requires-Dist: abstractcore[all-gpu]>=2.13.13; extra == 'all-gpu'
+Requires-Dist: abstractcore[all-gpu]>=2.13.14; extra == 'all-gpu'
 Provides-Extra: apple
-Requires-Dist: abstractcore[apple]>=2.13.13; extra == 'apple'
+Requires-Dist: abstractcore[apple]>=2.13.14; extra == 'apple'
 Provides-Extra: docs
 Requires-Dist: mkdocs-material>=9.0.0; extra == 'docs'
 Requires-Dist: mkdocs>=1.6.0; extra == 'docs'
 Requires-Dist: pymdown-extensions>=10.0; extra == 'docs'
 Provides-Extra: gpu
-Requires-Dist: abstractcore[gpu]>=2.13.13; extra == 'gpu'
+Requires-Dist: abstractcore[gpu]>=2.13.14; extra == 'gpu'
 Provides-Extra: mcp-worker
-Requires-Dist: abstractcore[tools]>=2.13.13; extra == 'mcp-worker'
+Requires-Dist: abstractcore[tools]>=2.13.14; extra == 'mcp-worker'
 Provides-Extra: multimodal
-Requires-Dist: abstractcore[audio,media,openai,vision,voice]>=2.13.13; extra == 'multimodal'
+Requires-Dist: abstractcore[audio,media,openai,vision,voice]>=2.13.14; extra == 'multimodal'
 Provides-Extra: test
 Requires-Dist: pytest>=7.0.0; extra == 'test'
 Description-Content-Type: text/markdown

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "AbstractRuntime"
-version = "0.4.10"
+version = "0.4.11"
 description = "AbstractRuntime: a durable graph runner designed to pair with AbstractCore."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -46,34 +46,34 @@ dependencies = [
 [project.optional-dependencies]
 # Enables `abstractruntime.integrations.abstractcore.*` imports.
 abstractcore = [
-  "abstractcore>=2.13.13",
+  "abstractcore>=2.13.14",
 ]
 
 apple = [
-  "abstractcore[apple]>=2.13.13",
+  "abstractcore[apple]>=2.13.14",
 ]
 
 gpu = [
-  "abstractcore[gpu]>=2.13.13",
+  "abstractcore[gpu]>=2.13.14",
 ]
 
 all-apple = [
-  "abstractcore[all-apple]>=2.13.13",
+  "abstractcore[all-apple]>=2.13.14",
 ]
 
 all-gpu = [
-  "abstractcore[all-gpu]>=2.13.13",
+  "abstractcore[all-gpu]>=2.13.14",
 ]
 
 # Enables AbstractCore multimodal generation helpers with common OpenAI-backed
 # image/voice capability packages.
 multimodal = [
-  "abstractcore[media,openai,vision,voice,audio]>=2.13.13",
+  "abstractcore[media,openai,vision,voice,audio]>=2.13.14",
 ]
 
 # Enables `abstractruntime-mcp-worker` with the default toolsets (includes bs4/lxml).
 mcp-worker = [
-  "abstractcore[tools]>=2.13.13",
+  "abstractcore[tools]>=2.13.14",
 ]
 
 # CI/test dependencies. The workflow runs the basic contract suite plus focused

abstractruntime-0.4.11/release-notes.md

@@ -0,0 +1,6 @@
+### Fixed
+- AbstractCore effect-handler media materialization now preserves artifact `content_type`, media `type`, artifact ids, and safe filename extensions instead of dropping artifact-backed media to bare paths. This keeps generated WAV artifacts valid for downstream transcription nodes.
+- Added explicit MIME extension aliases for common generated media types such as `audio/wav`, `image/png`, and `video/mp4` so platform MIME table differences do not create extensionless temp files.
+
+### Changed
+- Minimum AbstractCore optional dependency floor is now `abstractcore>=2.13.14`.

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/src/abstractruntime/integrations/abstractcore/effect_handlers.py

@@ -63,6 +63,23 @@ def _guess_ext_from_content_type(content_type: str) -> str:
     ct = str(content_type or "").strip().lower()
     if not ct:
         return ""
+    explicit = {
+        "audio/wav": ".wav",
+        "audio/wave": ".wav",
+        "audio/x-wav": ".wav",
+        "audio/mpeg": ".mp3",
+        "audio/mp3": ".mp3",
+        "audio/ogg": ".ogg",
+        "audio/flac": ".flac",
+        "image/jpeg": ".jpg",
+        "image/jpg": ".jpg",
+        "image/png": ".png",
+        "image/webp": ".webp",
+        "video/mp4": ".mp4",
+        "video/quicktime": ".mov",
+    }
+    if ct in explicit:
+        return explicit[ct]
     ext = mimetypes.guess_extension(ct) or ""
     if ext == ".jpe":
         return ".jpg"
@@ -679,9 +696,21 @@ def _resolve_llm_call_media(
             raw_name = source_path or item.get("filename") or item.get("name")
             if isinstance(raw_name, str) and raw_name.strip():
                 filename = raw_name.strip()
+        content_type = ""
+        if isinstance(item, dict):
+            for key in ("content_type", "mime_type", "mimeType", "mime"):
+                raw_ct = item.get(key)
+                if isinstance(raw_ct, str) and raw_ct.strip():
+                    content_type = raw_ct.strip()
+                    break
+        if not content_type:
+            raw_artifact_ct = getattr(artifact, "content_type", None)
+            if isinstance(raw_artifact_ct, str) and raw_artifact_ct.strip():
+                content_type = raw_artifact_ct.strip()
+
         ext = Path(filename).suffix if filename else ""
         if not ext:
-            ct = str(getattr(getattr(artifact, "metadata", None), "content_type", "") or "")
+            ct = content_type or str(getattr(getattr(artifact, "metadata", None), "content_type", "") or "")
             ext = _guess_ext_from_content_type(ct)
 
         desired = source_path or filename or artifact_id
@@ -691,7 +720,19 @@ def _resolve_llm_call_media(
             p.write_bytes(bytes(content))
         except Exception as e:
             return None, f"Failed to materialize artifact '{artifact_id}': {e}"
-        out.append(str(p))
+        resolved: Dict[str, Any] = {"file_path": str(p), "$artifact": str(artifact_id), "artifact_id": str(artifact_id)}
+        if content_type:
+            resolved["content_type"] = content_type
+            base_type = content_type.split(";", 1)[0].strip().lower()
+            if base_type.startswith("audio/"):
+                resolved["type"] = "audio"
+            elif base_type.startswith("image/"):
+                resolved["type"] = "image"
+            elif base_type.startswith("video/"):
+                resolved["type"] = "video"
+            elif base_type.startswith("text/"):
+                resolved["type"] = "text"
+        out.append(resolved)
 
     return (out or None), None
 

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/src/abstractruntime/integrations/abstractcore/llm_client.py

@@ -842,8 +842,24 @@ def _resolve_media_artifacts(
                     file_path = ""
 
         if file_path:
-            # Return a raw file path to trigger AutoMediaHandler processing.
-            out.append(str(file_path))
+            # Preserve content type alongside the resolved path. Artifact stores
+            # often use extensionless content paths, so a raw path can lose the
+            # modality and make downstream transcription reject valid audio.
+            resolved: Dict[str, Any] = {"file_path": str(file_path)}
+            if content_type:
+                resolved["content_type"] = str(content_type)
+                base_type = str(content_type).split(";", 1)[0].strip().lower()
+                if base_type.startswith("audio/"):
+                    resolved["type"] = "audio"
+                elif base_type.startswith("image/"):
+                    resolved["type"] = "image"
+                elif base_type.startswith("video/"):
+                    resolved["type"] = "video"
+                elif base_type.startswith("text/"):
+                    resolved["type"] = "text"
+            resolved["artifact_id"] = str(aid)
+            resolved["$artifact"] = str(aid)
+            out.append(resolved)
             continue
 
         raise ValueError(f"Unable to resolve artifact '{aid}' to provider-ready media content.")

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/src/abstractruntime/visualflow_compiler/visual/executor.py

@@ -1580,8 +1580,8 @@ def visual_to_flow(visual: VisualFlow) -> Flow:
                 output_spec["extra"] = dict(extra)
             image_provider = _nonempty_str(_input_or_config(payload, config, "image_provider", "imageProvider"))
             image_model = _nonempty_str(_input_or_config(payload, config, "image_model", "imageModel"))
-            legacy_provider = _nonempty_str(_input_or_config(payload, config, "provider"))
-            legacy_model = _nonempty_str(_input_or_config(payload, config, "model"))
+            legacy_provider = _nonempty_str(config.get("provider"))
+            legacy_model = _nonempty_str(config.get("model"))
             runtime_provider = _nonempty_str(
                 _input_or_config(payload, config, "runtime_provider", "runtimeProvider", "llm_provider", "llmProvider")
             )
@@ -1622,8 +1622,12 @@ def visual_to_flow(visual: VisualFlow) -> Flow:
                 value = _input_or_config(payload, config, key)
                 if isinstance(value, str) and value.strip():
                     output_spec[key] = value.strip()
-            tts_provider = _nonempty_str(_input_or_config(payload, config, "tts_provider", "ttsProvider", "provider"))
-            tts_model = _nonempty_str(_input_or_config(payload, config, "tts_model", "ttsModel", "model"))
+            tts_provider = _nonempty_str(_input_or_config(payload, config, "tts_provider", "ttsProvider"))
+            tts_model = _nonempty_str(_input_or_config(payload, config, "tts_model", "ttsModel"))
+            if not tts_provider:
+                tts_provider = _nonempty_str(config.get("provider"))
+            if not tts_model:
+                tts_model = _nonempty_str(config.get("model"))
             runtime_provider = _nonempty_str(
                 _input_or_config(payload, config, "runtime_provider", "runtimeProvider", "llm_provider", "llmProvider")
             )
@@ -1665,8 +1669,12 @@ def visual_to_flow(visual: VisualFlow) -> Flow:
                 value = _input_or_config(payload, config, key)
                 if isinstance(value, str) and value.strip():
                     output_spec[key] = value.strip()
-            stt_provider = _nonempty_str(_input_or_config(payload, config, "stt_provider", "sttProvider", "provider"))
-            stt_model = _nonempty_str(_input_or_config(payload, config, "stt_model", "sttModel", "model"))
+            stt_provider = _nonempty_str(_input_or_config(payload, config, "stt_provider", "sttProvider"))
+            stt_model = _nonempty_str(_input_or_config(payload, config, "stt_model", "sttModel"))
+            if not stt_provider:
+                stt_provider = _nonempty_str(config.get("provider"))
+            if not stt_model:
+                stt_model = _nonempty_str(config.get("model"))
             runtime_provider = _nonempty_str(
                 _input_or_config(payload, config, "runtime_provider", "runtimeProvider", "llm_provider", "llmProvider")
             )
@@ -1709,6 +1717,9 @@ def visual_to_flow(visual: VisualFlow) -> Flow:
             language = _input_or_config(payload, config, "language")
             if isinstance(language, str) and language.strip():
                 details["language"] = language.strip()
+            stt_model = _nonempty_str(_input_or_config(payload, config, "stt_model", "sttModel", "model"))
+            if stt_model:
+                details["model"] = stt_model
             max_duration_s = _coerce_float(_input_or_config(payload, config, "max_duration_s", "maxDurationS"))
             if max_duration_s is not None:
                 details["max_duration_s"] = max_duration_s

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/tests/test_llm_client_media_artifacts.py

@@ -21,6 +21,11 @@ def test_resolve_media_artifact_creates_file_path() -> None:
     assert isinstance(resolved, list)
     assert resolved
     item = resolved[0]
-    assert isinstance(item, str)
-    assert os.path.exists(item)
-    os.remove(item)
+    assert isinstance(item, dict)
+    assert item.get("$artifact") == meta.artifact_id
+    assert item.get("artifact_id") == meta.artifact_id
+    assert item.get("content_type") == "image/png"
+    assert item.get("type") == "image"
+    path = str(item.get("file_path") or "")
+    assert os.path.exists(path)
+    os.remove(path)

abstractruntime-0.4.11/tests/test_media_artifact_resolution.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def test_resolved_audio_artifact_preserves_content_type_for_transcription(tmp_path: Path) -> None:
+    from abstractcore.providers.base import BaseProvider
+    from abstractruntime.integrations.abstractcore.llm_client import _is_audio_media_item, _resolve_media_artifacts
+
+    content_path = tmp_path / "artifact-content-without-extension"
+    content_path.write_bytes(b"RIFF\x00\x00\x00\x00WAVE")
+
+    class Store:
+        def _content_path(self, artifact_id: str) -> Path:
+            assert artifact_id == "audio-1"
+            return content_path
+
+    resolved = _resolve_media_artifacts(
+        [{"$artifact": "audio-1", "content_type": "audio/wav"}],
+        artifact_store=Store(),
+    )
+
+    assert isinstance(resolved, list)
+    assert resolved == [
+        {
+            "$artifact": "audio-1",
+            "artifact_id": "audio-1",
+            "content_type": "audio/wav",
+            "file_path": str(content_path),
+            "type": "audio",
+        }
+    ]
+    assert _is_audio_media_item(resolved[0]) is True
+    assert BaseProvider._media_type(resolved[0]) == "audio"
+
+
+def test_effect_handler_materialized_audio_artifact_preserves_content_type(tmp_path: Path) -> None:
+    from abstractcore.providers.base import BaseProvider
+    from abstractruntime.integrations.abstractcore.effect_handlers import _resolve_llm_call_media
+
+    class Artifact:
+        content = b"RIFF\x00\x00\x00\x00WAVE"
+        content_type = None
+        metadata = None
+
+    class Store:
+        def load(self, artifact_id: str) -> Artifact:
+            assert artifact_id == "audio-1"
+            return Artifact()
+
+    resolved, error = _resolve_llm_call_media(
+        [{"$artifact": "audio-1", "content_type": "audio/wav"}],
+        artifact_store=Store(),
+        temp_dir=tmp_path,
+    )
+
+    assert error is None
+    assert isinstance(resolved, list)
+    assert len(resolved) == 1
+    item = resolved[0]
+    assert item["$artifact"] == "audio-1"
+    assert item["artifact_id"] == "audio-1"
+    assert item["content_type"] == "audio/wav"
+    assert item["type"] == "audio"
+    assert Path(item["file_path"]).suffix == ".wav"
+    assert BaseProvider._media_type(item) == "audio"

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/tests/test_multimodal_abstractcore_integration.py

@@ -205,7 +205,14 @@ def test_llm_call_allows_media_only_transcription_output_and_augments_output_spe
 
     assert state.output["llm"]["content"] == "transcribed text"
     assert seen["prompt"] == ""
-    assert isinstance(seen["media"], list) and seen["media"][0].endswith(".wav")
+    assert isinstance(seen["media"], list)
+    media_item = seen["media"][0]
+    assert isinstance(media_item, dict)
+    assert media_item.get("$artifact") == meta.artifact_id
+    assert media_item.get("artifact_id") == meta.artifact_id
+    assert media_item.get("content_type") == "audio/wav"
+    assert media_item.get("type") == "audio"
+    assert str(media_item.get("file_path") or "").endswith(".wav")
     output = seen["params"]["output"]
     assert output["modality"] == "text"
     assert output["run_id"] == run_id

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/tests/test_session_attachments_registry_and_open_tool.py

@@ -434,7 +434,15 @@ def test_tool_calls_open_attachment_binary_enqueues_pending_media_and_llm_call_c
             # Validate that the resolved media file exists during the call.
             media = kwargs.get("media")
             assert isinstance(media, list) and len(media) == 1
-            p = Path(str(media[0]))
+            item = media[0]
+            if isinstance(item, dict):
+                assert item.get("$artifact") == meta.artifact_id
+                assert item.get("artifact_id") == meta.artifact_id
+                assert item.get("content_type") == "image/jpeg"
+                assert item.get("type") == "image"
+                p = Path(str(item.get("file_path") or ""))
+            else:
+                p = Path(str(item))
             assert p.exists()
             assert p.read_bytes() == content
             return {"content": "ok", "metadata": {}}

{abstractruntime-0.4.10 → abstractruntime-0.4.11}/tests/test_visualflow_media_nodes.py

@@ -4,7 +4,7 @@ from abstractruntime.core.models import EffectType, RunState, RunStatus
 from abstractruntime.visualflow_compiler import compile_visualflow
 
 
-def _plan_for_node(node_type: str, effect_config: dict) -> object:
+def _plan_for_node(node_type: str, effect_config: dict, input_data: dict | None = None) -> object:
     spec = compile_visualflow(
         {
             "id": f"vf_{node_type}",
@@ -27,7 +27,7 @@ def _plan_for_node(node_type: str, effect_config: dict) -> object:
         current_node="node",
         vars={"_temp": {}},
     )
-    return spec.nodes["node"](run, None)
+    return spec.nodes["node"](run, input_data)
 
 
 def test_generate_image_node_compiles_to_llm_call_output_selector() -> None:
@@ -82,6 +82,20 @@ def test_generate_image_legacy_provider_model_stay_in_output_spec() -> None:
     assert output["model"] == "flux-test"
 
 
+def test_generate_image_does_not_treat_runtime_provider_input_as_image_provider() -> None:
+    plan = _plan_for_node(
+        "generate_image",
+        {"prompt": "a horse", "image_model": "gpt-image-1-mini"},
+        {"provider": "lmstudio", "model": "chat-model"},
+    )
+
+    assert plan.effect is not None
+    payload = dict(plan.effect.payload or {})
+    output = dict(payload.get("output") or {})
+    assert "provider" not in output
+    assert output["model"] == "gpt-image-1-mini"
+
+
 def test_generate_voice_node_compiles_to_llm_call_tts_selector() -> None:
     plan = _plan_for_node(
         "generate_voice",
@@ -143,6 +157,7 @@ def test_listen_voice_node_compiles_to_voice_wait_event() -> None:
             "prompt": "Say your answer",
             "wait_key": "voice_answer",
             "language": "fr",
+            "stt_model": "whisper-test",
             "max_duration_s": 12,
         },
     )
@@ -156,4 +171,5 @@ def test_listen_voice_node_compiles_to_voice_wait_event() -> None:
     assert payload["allow_free_text"] is True
     assert details["input_mode"] == "voice"
     assert details["language"] == "fr"
+    assert details["model"] == "whisper-test"
     assert details["max_duration_s"] == 12.0

abstractruntime-0.4.10/release-notes.md

@@ -1,6 +0,0 @@
-### Fixed
-- Generated media VisualFlow nodes now keep media model selection in the output spec and reserve LLM `provider`/`model` routing for explicit `runtime_provider`/`runtime_model` overrides.
-- Legacy `provider`/`model` pins on image, TTS, and STT media nodes remain accepted as media selector fallbacks for existing flows.
-
-### Changed
-- Minimum AbstractCore optional dependency floor is now `abstractcore>=2.13.13` so generated media and audio catalog contracts stay aligned.