prompture 1.0.56.dev1__tar.gz → 1.0.56.dev2__tar.gz

{prompture-1.0.56.dev1 → prompture-1.0.56.dev2}/.env.copy

@@ -90,3 +90,7 @@ AIRLLM_COMPRESSION=
 
 # ─── Stability AI (image generation) ────────────────────────────────────────
 STABILITY_API_KEY=
+
+# ─── Runway (image / video / audio) ─────────────────────────────────────────
+# Either RUNWAY_API_KEY or RUNWAYML_API_SECRET is accepted.
+RUNWAY_API_KEY=

{prompture-1.0.56.dev1 → prompture-1.0.56.dev2}/CLAUDE.md

@@ -61,15 +61,15 @@ Configuration is in `pyproject.toml` under `[tool.ruff]`.
 ### Module Layout
 
 - **`prompture/core.py`** — Primary business logic. All extraction functions live here: `ask_for_json()` (low-level schema enforcement), `extract_and_jsonify()` / `manual_extract_and_jsonify()` (text-to-JSON), `extract_with_model()` / `stepwise_extract_with_model()` (Pydantic-based), `extract_from_data()` / `extract_from_pandas()` (TOON input), `render_output()` (raw text formatting).
-- **`prompture/drivers/`** — One module per LLM provider (openai, claude, google, groq, grok, azure, ollama, lmstudio, openrouter, local_http, huggingface, airllm). Each driver implements `generate(prompt, options)` returning a standardized response with token/cost metadata.
+- **`prompture/drivers/`** — One module per provider × modality. LLM drivers (openai, claude, google, groq, grok, azure, ollama, lmstudio, openrouter, local_http, huggingface, airllm, moonshot, modelscope, zai, cachibot, …) implement `generate(prompt, options)`; non-LLM drivers implement modality-specific methods (`generate_image`, `generate_video`, `synthesize`, etc.). Each provider also has an `async_*` sibling. Registration is centralized in `provider_descriptors.py` via `ProviderDescriptor` with lazy `DriverSpec.cls_path` resolution.
 - **`prompture/drivers/__init__.py`** — Central `DRIVER_REGISTRY` dict mapping provider name to factory lambda. `get_driver_for_model("provider/model")` parses the string and instantiates the right driver. `get_driver("provider")` is the legacy interface.
 - **`prompture/tools.py`** — Utilities: JSON/TOON text cleanup, type conversion (shorthand numbers, multilingual booleans, datetimes), field schema generation.
 - **`prompture/logging.py`** — Library logging configuration: `JSONFormatter` for structured JSON-lines output, `configure_logging()` for enabling library-level logging via Python stdlib `logging`.
 - **`prompture/callbacks.py`** — `DriverCallbacks` dataclass with `on_request`, `on_response`, `on_error` hooks for driver-level observability.
 - **`prompture/session.py`** — `UsageSession` dataclass for tracking token counts, costs, and errors across multiple driver calls.
 - **`prompture/field_definitions.py`** — Thread-safe global field registry with 50+ predefined fields, template variable substitution (`{{current_year}}`, `{{current_date}}`), and Pydantic Field generation via `field_from_registry()`.
-- **`prompture/settings.py`** — Pydantic-settings `Settings` class loading provider API keys/endpoints from `.env`.
-- **`prompture/discovery.py`** — `get_available_models()` auto-detects models from configured providers (static pricing tables + dynamic Ollama endpoint query).
+- **`prompture/infra/settings.py`** — Pydantic-settings `Settings` class loading provider API keys/endpoints from `.env`.
+- **`prompture/infra/discovery.py`** — `get_available_models()` plus per-modality helpers (`get_available_image_gen_models`, `get_available_video_gen_models`, `get_available_audio_models`). Auto-detects models from configured providers via static `*_PRICING` / `KNOWN_MODELS` tables, dynamic provider listing endpoints (Ollama, ElevenLabs), and models.dev capability fallback.
 - **`prompture/runner.py`** — Spec-driven test suite runner for cross-model comparison.
 - **`prompture/validator.py`** — JSON schema validation via jsonschema with fallback.
 
@@ -80,6 +80,21 @@ Configuration is in `pyproject.toml` under `[tool.ruff]`.
 - **Output formats**: JSON (default) and TOON (experimental, for compact output). Controlled via `output_format` parameter.
 - **TOON input conversion** uses `python-toon` and `tukuy` packages to reduce token usage by 45-60% when sending structured data to LLMs.
 
+### Multi-Modal Drivers
+
+Beyond LLMs, drivers exist for adjacent modalities. Each modality has its own base class, registry, and factory:
+
+- **Image generation** (`ImageGenDriver` / `img_gen_registry.get_img_gen_driver_for_model`) — OpenAI DALL-E + GPT image, Google Imagen, Grok, Stability AI, Runway.
+- **Video generation** (`VideoGenDriver` / `video_gen_registry.get_video_gen_driver_for_model`) — Grok Imagine Video; Runway (text/image/video → video via a single driver, mode auto-detected from options).
+- **TTS** (`TTSDriver` / `audio_registry.get_tts_driver_for_model`) — OpenAI, ElevenLabs, Runway (TTS + sound effects).
+- **STT** (`STTDriver` / `audio_registry.get_stt_driver_for_model`) — OpenAI Whisper, ElevenLabs.
+- **Embeddings** (`EmbeddingDriver`) — OpenAI, Ollama.
+- **Standalone helpers** (not modality-registered) — `RunwayAudioTransformDriver` for voice dubbing / isolation / speech-to-speech; instantiated directly.
+
+**Runway is the only provider spanning image + video + TTS + sound-effects + voice transforms under one API key** (`RUNWAY_API_KEY` or `RUNWAYML_API_SECRET`). Per-model capabilities live in `prompture/drivers/runway_capabilities.py` (`RUNWAY_MODEL_INFO`, `get_runway_model_info`, `get_runway_models_by_op`, `get_runway_models_by_modality`) — use this when you need to answer "which models support text_to_video?" without instantiating drivers.
+
+Discovery for non-LLM modalities: `infra/discovery.py` exposes `get_available_image_gen_models`, `get_available_video_gen_models`, `get_available_audio_models(modality="tts" | "stt" | None)`.
+
 ### Testing
 
 Tests live in `tests/`. Integration tests that call live LLMs are marked with `@pytest.mark.integration` and skipped by default. The default test model is set in `tests/conftest.py` as `DEFAULT_MODEL`. Shared fixtures and assertion helpers (`assert_valid_usage_metadata`, `assert_jsonify_response_structure`) are in `conftest.py`.

{prompture-1.0.56.dev1 → prompture-1.0.56.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.0.56.dev1
+Version: 1.0.56.dev2
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT
@@ -95,8 +95,8 @@ print(person.name)  # Maria
 ## Key Features
 
 - **Structured output** — JSON schema enforcement and direct Pydantic model population
-- **17+ providers** — OpenAI, Claude, Google, Groq, Grok, Azure, Ollama, LM Studio, OpenRouter, HuggingFace, Moonshot, ModelScope, Z.ai, Vertex AI, AirLLM, CachiBot, and generic HTTP
-- **Multi-modal** — Drivers for embeddings, image generation (DALL-E, Imagen, Grok, Stability), video generation (Grok Imagine Video), text-to-speech, and speech-to-text (Whisper, ElevenLabs)
+- **18+ providers** — OpenAI, Claude, Google, Groq, Grok, Azure, Ollama, LM Studio, OpenRouter, HuggingFace, Moonshot, ModelScope, Z.ai, Vertex AI, AirLLM, CachiBot, Runway, and generic HTTP
+- **Multi-modal** — Drivers for embeddings, image generation (DALL-E, Imagen, Grok, Stability, Runway), video generation (Grok Imagine Video, Runway text/image/video → video), text-to-speech (OpenAI, ElevenLabs, Runway), sound effects, voice dubbing / isolation / conversion (Runway), and speech-to-text (Whisper, ElevenLabs)
 - **Multi-model fallback** — Try a list of models in sequence with per-attempt cost, token, and capability accounting
 - **Strategy cascade** — Auto-selects between provider-native JSON mode, tool-call extraction, and prompted repair so extraction works on any model
 - **TOON input conversion** — 45-60% token savings when sending structured data via [Token-Oriented Object Notation](https://github.com/jhd3197/python-toon)
@@ -191,17 +191,20 @@ Model strings use `"provider/model"` format. The provider prefix routes to the c
 | `huggingface` | `hf/model-name` | Free (local) |
 | `airllm` | `airllm/Qwen2-7B` | Free (local) |
 | `local_http` | `local_http/self-hosted` | Free |
+| `runway` | `runway/gen4.5` (video), `runway/gpt_image_2` (image), `runway/eleven_multilingual_v2` (TTS) | Automatic |
 
-Aliases (`anthropic`, `gemini`, `chatgpt`, `xai`, `lm_studio`, `zhipu`, `hf`, `dalle`) route to their canonical providers.
+Aliases (`anthropic`, `gemini`, `chatgpt`, `xai`, `lm_studio`, `zhipu`, `hf`, `dalle`, `runwayml`) route to their canonical providers.
 
 ## Multi-Modal
 
 Beyond text LLMs, Prompture exposes drivers for adjacent modalities under the same `provider/model` routing:
 
 - **Embeddings** — OpenAI (`text-embedding-3-*`) and Ollama (`nomic-embed-text`)
-- **Image generation** — OpenAI DALL-E, Google Imagen, Grok, Stability AI
-- **Video generation** — Grok Imagine Video (`grok-imagine-video`) with text-to-video, image-to-video, reference images, and polling
-- **Text-to-speech** — OpenAI (`tts-1`) and ElevenLabs
+- **Image generation** — OpenAI DALL-E + GPT image, Google Imagen, Grok, Stability AI, Runway (`gen4_image`, `gen4_image_turbo`, `gpt_image_2`, `gemini_image3_pro`, `gemini_2.5_flash`)
+- **Video generation** — Grok Imagine Video; Runway text/image/video → video (`gen4.5`, `gen4_turbo`, `gen3a_turbo`, `gen4_aleph`, `veo3`, `veo3.1`, `veo3.1_fast`)
+- **Text-to-speech** — OpenAI (`tts-1`), ElevenLabs, Runway (`eleven_multilingual_v2`)
+- **Sound effects** — Runway (`eleven_text_to_sound_v2`)
+- **Audio transforms** — Runway voice dubbing, voice isolation, speech-to-speech (`RunwayAudioTransformDriver`)
 - **Speech-to-text** — OpenAI Whisper and ElevenLabs
 
 ```python
@@ -235,6 +238,61 @@ For local smoke tests without waiting on the render, pass `{"poll": False}` to g
 
 Runnable example: `python examples/grok_video_generation_example.py`.
 
+### Runway
+
+Runway is a single API surface covering image, video, and audio. One key (`RUNWAY_API_KEY`, or `RUNWAYML_API_SECRET`) unlocks all of it:
+
+```python
+from prompture.drivers.img_gen_registry import get_img_gen_driver_for_model
+from prompture.drivers.video_gen_registry import get_video_gen_driver_for_model
+from prompture.drivers.audio_registry import get_tts_driver_for_model
+from prompture.drivers import RunwayAudioTransformDriver
+
+# Image — text_to_image, optionally with reference images
+img = get_img_gen_driver_for_model("runway/gpt_image_2").generate_image(
+    "A cinematic wide shot of a neon-lit Tokyo alleyway at night in the rain",
+    {"ratio": "1920:1080", "quality": "high"},
+)
+
+# Video — one driver, three modes (auto-detected from inputs)
+vid = get_video_gen_driver_for_model("runway/gen4.5").generate_video(
+    "wide cinematic shot of a rocket launching from desert dunes",
+    {"ratio": "1280:720", "duration": 5},          # text_to_video
+)
+# Pass `image=...` → image_to_video; `video=...` → video_to_video (gen4_aleph).
+
+# Speech and sound effects
+tts = get_tts_driver_for_model("runway/eleven_multilingual_v2").synthesize(
+    "Hello from Runway via Prompture.", {"voice": "Maya"},
+)
+sfx = get_tts_driver_for_model("runway/eleven_text_to_sound_v2").synthesize(
+    "Heavy tropical rain on a metal roof", {"duration": 5},
+)
+
+# Voice transforms (audio in → audio out, not a registered modality)
+dub = RunwayAudioTransformDriver().dub("https://.../speech.mp3", target_lang="es")
+```
+
+Inspect any model's capabilities (operations, endpoints, cost) as data — no need to instantiate the driver:
+
+```python
+from prompture.drivers import get_runway_model_info, get_runway_models_by_op
+
+get_runway_model_info("gen4.5")
+# {'modality': 'video',
+#  'operations': ['text_to_video', 'image_to_video'],
+#  'endpoints':  ['/v1/text_to_video', '/v1/image_to_video'],
+#  'cost': '$0.12 per second'}
+
+get_runway_models_by_op("text_to_video")
+# ['gen4.5', 'veo3', 'veo3.1', 'veo3.1_fast']
+```
+
+Runnable examples:
+- `python examples/runway_image_generation_example.py`
+- `python examples/runway_video_generation_example.py`
+- `python examples/runway_audio_example.py`
+
 ## Usage
 
 ### One-Shot Pydantic Extraction
@@ -508,6 +566,20 @@ for model in models:
     print(model)  # "openai/gpt-4", "ollama/llama3:latest", ...
 ```
 
+For non-LLM modalities, use the matching helper:
+
+```python
+from prompture.infra.discovery import (
+    get_available_image_gen_models,
+    get_available_video_gen_models,
+    get_available_audio_models,
+)
+
+get_available_image_gen_models()        # ['runway/gpt_image_2', 'openai/dall-e-3', ...]
+get_available_video_gen_models()        # ['runway/gen4.5', 'runway/gen4_aleph', ...]
+get_available_audio_models(modality="tts")  # ['runway/eleven_multilingual_v2', ...]
+```
+
 ### Logging and Debugging
 
 ```python

{prompture-1.0.56.dev1 → prompture-1.0.56.dev2}/README.md

@@ -31,8 +31,8 @@ print(person.name)  # Maria
 ## Key Features
 
 - **Structured output** — JSON schema enforcement and direct Pydantic model population
-- **17+ providers** — OpenAI, Claude, Google, Groq, Grok, Azure, Ollama, LM Studio, OpenRouter, HuggingFace, Moonshot, ModelScope, Z.ai, Vertex AI, AirLLM, CachiBot, and generic HTTP
-- **Multi-modal** — Drivers for embeddings, image generation (DALL-E, Imagen, Grok, Stability), video generation (Grok Imagine Video), text-to-speech, and speech-to-text (Whisper, ElevenLabs)
+- **18+ providers** — OpenAI, Claude, Google, Groq, Grok, Azure, Ollama, LM Studio, OpenRouter, HuggingFace, Moonshot, ModelScope, Z.ai, Vertex AI, AirLLM, CachiBot, Runway, and generic HTTP
+- **Multi-modal** — Drivers for embeddings, image generation (DALL-E, Imagen, Grok, Stability, Runway), video generation (Grok Imagine Video, Runway text/image/video → video), text-to-speech (OpenAI, ElevenLabs, Runway), sound effects, voice dubbing / isolation / conversion (Runway), and speech-to-text (Whisper, ElevenLabs)
 - **Multi-model fallback** — Try a list of models in sequence with per-attempt cost, token, and capability accounting
 - **Strategy cascade** — Auto-selects between provider-native JSON mode, tool-call extraction, and prompted repair so extraction works on any model
 - **TOON input conversion** — 45-60% token savings when sending structured data via [Token-Oriented Object Notation](https://github.com/jhd3197/python-toon)
@@ -127,17 +127,20 @@ Model strings use `"provider/model"` format. The provider prefix routes to the c
 | `huggingface` | `hf/model-name` | Free (local) |
 | `airllm` | `airllm/Qwen2-7B` | Free (local) |
 | `local_http` | `local_http/self-hosted` | Free |
+| `runway` | `runway/gen4.5` (video), `runway/gpt_image_2` (image), `runway/eleven_multilingual_v2` (TTS) | Automatic |
 
-Aliases (`anthropic`, `gemini`, `chatgpt`, `xai`, `lm_studio`, `zhipu`, `hf`, `dalle`) route to their canonical providers.
+Aliases (`anthropic`, `gemini`, `chatgpt`, `xai`, `lm_studio`, `zhipu`, `hf`, `dalle`, `runwayml`) route to their canonical providers.
 
 ## Multi-Modal
 
 Beyond text LLMs, Prompture exposes drivers for adjacent modalities under the same `provider/model` routing:
 
 - **Embeddings** — OpenAI (`text-embedding-3-*`) and Ollama (`nomic-embed-text`)
-- **Image generation** — OpenAI DALL-E, Google Imagen, Grok, Stability AI
-- **Video generation** — Grok Imagine Video (`grok-imagine-video`) with text-to-video, image-to-video, reference images, and polling
-- **Text-to-speech** — OpenAI (`tts-1`) and ElevenLabs
+- **Image generation** — OpenAI DALL-E + GPT image, Google Imagen, Grok, Stability AI, Runway (`gen4_image`, `gen4_image_turbo`, `gpt_image_2`, `gemini_image3_pro`, `gemini_2.5_flash`)
+- **Video generation** — Grok Imagine Video; Runway text/image/video → video (`gen4.5`, `gen4_turbo`, `gen3a_turbo`, `gen4_aleph`, `veo3`, `veo3.1`, `veo3.1_fast`)
+- **Text-to-speech** — OpenAI (`tts-1`), ElevenLabs, Runway (`eleven_multilingual_v2`)
+- **Sound effects** — Runway (`eleven_text_to_sound_v2`)
+- **Audio transforms** — Runway voice dubbing, voice isolation, speech-to-speech (`RunwayAudioTransformDriver`)
 - **Speech-to-text** — OpenAI Whisper and ElevenLabs
 
 ```python
@@ -171,6 +174,61 @@ For local smoke tests without waiting on the render, pass `{"poll": False}` to g
 
 Runnable example: `python examples/grok_video_generation_example.py`.
 
+### Runway
+
+Runway is a single API surface covering image, video, and audio. One key (`RUNWAY_API_KEY`, or `RUNWAYML_API_SECRET`) unlocks all of it:
+
+```python
+from prompture.drivers.img_gen_registry import get_img_gen_driver_for_model
+from prompture.drivers.video_gen_registry import get_video_gen_driver_for_model
+from prompture.drivers.audio_registry import get_tts_driver_for_model
+from prompture.drivers import RunwayAudioTransformDriver
+
+# Image — text_to_image, optionally with reference images
+img = get_img_gen_driver_for_model("runway/gpt_image_2").generate_image(
+    "A cinematic wide shot of a neon-lit Tokyo alleyway at night in the rain",
+    {"ratio": "1920:1080", "quality": "high"},
+)
+
+# Video — one driver, three modes (auto-detected from inputs)
+vid = get_video_gen_driver_for_model("runway/gen4.5").generate_video(
+    "wide cinematic shot of a rocket launching from desert dunes",
+    {"ratio": "1280:720", "duration": 5},          # text_to_video
+)
+# Pass `image=...` → image_to_video; `video=...` → video_to_video (gen4_aleph).
+
+# Speech and sound effects
+tts = get_tts_driver_for_model("runway/eleven_multilingual_v2").synthesize(
+    "Hello from Runway via Prompture.", {"voice": "Maya"},
+)
+sfx = get_tts_driver_for_model("runway/eleven_text_to_sound_v2").synthesize(
+    "Heavy tropical rain on a metal roof", {"duration": 5},
+)
+
+# Voice transforms (audio in → audio out, not a registered modality)
+dub = RunwayAudioTransformDriver().dub("https://.../speech.mp3", target_lang="es")
+```
+
+Inspect any model's capabilities (operations, endpoints, cost) as data — no need to instantiate the driver:
+
+```python
+from prompture.drivers import get_runway_model_info, get_runway_models_by_op
+
+get_runway_model_info("gen4.5")
+# {'modality': 'video',
+#  'operations': ['text_to_video', 'image_to_video'],
+#  'endpoints':  ['/v1/text_to_video', '/v1/image_to_video'],
+#  'cost': '$0.12 per second'}
+
+get_runway_models_by_op("text_to_video")
+# ['gen4.5', 'veo3', 'veo3.1', 'veo3.1_fast']
+```
+
+Runnable examples:
+- `python examples/runway_image_generation_example.py`
+- `python examples/runway_video_generation_example.py`
+- `python examples/runway_audio_example.py`
+
 ## Usage
 
 ### One-Shot Pydantic Extraction
@@ -444,6 +502,20 @@ for model in models:
     print(model)  # "openai/gpt-4", "ollama/llama3:latest", ...
 ```
 
+For non-LLM modalities, use the matching helper:
+
+```python
+from prompture.infra.discovery import (
+    get_available_image_gen_models,
+    get_available_video_gen_models,
+    get_available_audio_models,
+)
+
+get_available_image_gen_models()        # ['runway/gpt_image_2', 'openai/dall-e-3', ...]
+get_available_video_gen_models()        # ['runway/gen4.5', 'runway/gen4_aleph', ...]
+get_available_audio_models(modality="tts")  # ['runway/eleven_multilingual_v2', ...]
+```
+
 ### Logging and Debugging
 
 ```python

{prompture-1.0.56.dev1 → prompture-1.0.56.dev2}/prompture/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.56.dev1'
-__version_tuple__ = version_tuple = (1, 0, 56, 'dev1')
+__version__ = version = '1.0.56.dev2'
+__version_tuple__ = version_tuple = (1, 0, 56, 'dev2')
 
 __commit_id__ = commit_id = None

{prompture-1.0.56.dev1 → prompture-1.0.56.dev2}/prompture/drivers/__init__.py

@@ -57,6 +57,9 @@ from .async_openai_img_gen_driver import AsyncOpenAIImageGenDriver
 from .async_openai_stt_driver import AsyncOpenAISTTDriver
 from .async_openai_tts_driver import AsyncOpenAITTSDriver
 from .async_openrouter_driver import AsyncOpenRouterDriver
+from .async_runway_img_gen_driver import AsyncRunwayImageGenDriver
+from .async_runway_tts_driver import AsyncRunwayTTSDriver
+from .async_runway_video_gen_driver import AsyncRunwayVideoGenDriver
 from .async_stability_img_gen_driver import AsyncStabilityImageGenDriver
 from .async_stt_base import AsyncSTTDriver
 from .async_tts_base import AsyncTTSDriver
@@ -164,6 +167,22 @@ from .registry import (
     unregister_tts_driver,
     unregister_video_gen_driver,
 )
+from .runway_audio_transform_driver import RunwayAudioTransformDriver
+from .runway_capabilities import (
+    ALL_MODALITIES as RUNWAY_ALL_MODALITIES,
+)
+from .runway_capabilities import (
+    ALL_OPERATIONS as RUNWAY_ALL_OPERATIONS,
+)
+from .runway_capabilities import (
+    RUNWAY_MODEL_INFO,
+    get_runway_model_info,
+    get_runway_models_by_modality,
+    get_runway_models_by_op,
+)
+from .runway_img_gen_driver import RunwayImageGenDriver
+from .runway_tts_driver import RunwayTTSDriver
+from .runway_video_gen_driver import RunwayVideoGenDriver
 from .stability_img_gen_driver import StabilityImageGenDriver
 from .stt_base import STTDriver
 from .tts_base import TTSDriver
@@ -448,6 +467,9 @@ __all__ = [
     "PROVIDER_DRIVER_MAP",
     # Provider name mapping
     "PROVIDER_NAME_MAP",
+    "RUNWAY_ALL_MODALITIES",
+    "RUNWAY_ALL_OPERATIONS",
+    "RUNWAY_MODEL_INFO",
     # Sync LLM drivers
     "AirLLMDriver",
     # Async LLM drivers
@@ -483,6 +505,9 @@ __all__ = [
     "AsyncOpenAISTTDriver",
     "AsyncOpenAITTSDriver",
     "AsyncOpenRouterDriver",
+    "AsyncRunwayImageGenDriver",
+    "AsyncRunwayTTSDriver",
+    "AsyncRunwayVideoGenDriver",
     "AsyncSTTDriver",
     "AsyncStabilityImageGenDriver",
     "AsyncTTSDriver",
@@ -519,6 +544,10 @@ __all__ = [
     "OpenAISTTDriver",
     "OpenAITTSDriver",
     "OpenRouterDriver",
+    "RunwayAudioTransformDriver",
+    "RunwayImageGenDriver",
+    "RunwayTTSDriver",
+    "RunwayVideoGenDriver",
     # STT/TTS base classes
     "STTDriver",
     "StabilityImageGenDriver",
@@ -554,6 +583,9 @@ __all__ = [
     "get_embedding_driver_for_model",
     "get_img_gen_driver_factory",
     "get_img_gen_driver_for_model",
+    "get_runway_model_info",
+    "get_runway_models_by_modality",
+    "get_runway_models_by_op",
     "get_stt_driver_factory",
     "get_stt_driver_for_model",
     "get_tts_driver_factory",

{prompture-1.0.56.dev1 → prompture-1.0.56.dev2}/prompture/drivers/async_openai_img_gen_driver.py

@@ -48,15 +48,18 @@ class AsyncOpenAIImageGenDriver(ImageCostMixin, AsyncImageGenDriver):
             raise RuntimeError("openai package (>=1.0.0) is not installed")
 
         model = options.get("model", self.model)
+        is_gpt_image = model.startswith("gpt-image")
+        is_dalle3 = "dall-e-3" in model
+
         size = options.get("size", "1024x1024")
-        quality = options.get("quality", "standard")
+        default_quality = "high" if is_gpt_image else "standard"
+        quality = options.get("quality", default_quality)
         n = options.get("n", 1)
         style = options.get("style", "vivid")
 
         images = []
         revised_prompt = None
 
-        is_dalle3 = "dall-e-3" in model
         batch_size = 1 if is_dalle3 else n
 
         remaining = n
@@ -68,11 +71,14 @@ class AsyncOpenAIImageGenDriver(ImageCostMixin, AsyncImageGenDriver):
                 "prompt": prompt,
                 "n": batch_n,
                 "size": size,
-                "response_format": "b64_json",
             }
-            if is_dalle3:
+            if is_gpt_image:
                 kwargs["quality"] = quality
-                kwargs["style"] = style
+            else:
+                kwargs["response_format"] = "b64_json"
+                if is_dalle3:
+                    kwargs["quality"] = quality
+                    kwargs["style"] = style
 
             resp = await self.client.images.generate(**kwargs)
 

prompture-1.0.56.dev2/prompture/drivers/async_runway_img_gen_driver.py

@@ -0,0 +1,137 @@
+"""Async Runway image generation driver. Mirrors :mod:`runway_img_gen_driver`."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+from typing import Any
+
+import httpx
+
+from ..infra.cost_mixin import ImageCostMixin
+from .async_img_gen_base import AsyncImageGenDriver
+from .runway_img_gen_driver import (
+    _API_VERSION,
+    _DEFAULT_ENDPOINT,
+    _TERMINAL_FAIL,
+    _TERMINAL_OK,
+    RunwayImageGenDriver,
+    _format_error,
+    _get_runway_api_key,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncRunwayImageGenDriver(ImageCostMixin, AsyncImageGenDriver):
+    """Async image generation via Runway ``POST /v1/text_to_image``."""
+
+    supports_multiple = RunwayImageGenDriver.supports_multiple
+    supports_size_variants = RunwayImageGenDriver.supports_size_variants
+    supported_sizes = RunwayImageGenDriver.supported_sizes
+    max_images = RunwayImageGenDriver.max_images
+
+    KNOWN_MODELS = RunwayImageGenDriver.KNOWN_MODELS
+    IMAGE_PRICING = RunwayImageGenDriver.IMAGE_PRICING
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "gen4_image",
+        endpoint: str | None = None,
+    ):
+        self.api_key = _get_runway_api_key(api_key)
+        self.model = model
+        self.endpoint = (
+            endpoint or os.getenv("RUNWAY_ENDPOINT") or _DEFAULT_ENDPOINT
+        ).rstrip("/")
+
+    @classmethod
+    def list_models(cls, *, api_key: str | None = None, **kw: object) -> list[str] | None:
+        key = _get_runway_api_key(api_key)
+        if not key:
+            return None
+        return list(cls.KNOWN_MODELS)
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "X-Runway-Version": _API_VERSION,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+    async def generate_image(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
+        if not self.api_key:
+            raise RuntimeError(
+                "RUNWAY_API_KEY (or RUNWAYML_API_SECRET) is not configured"
+            )
+
+        # Reuse the sync driver's body-building logic to avoid duplication.
+        builder = RunwayImageGenDriver.__new__(RunwayImageGenDriver)
+        builder.model = self.model
+        model, body = builder._build_body(prompt, options)
+        headers = self._headers()
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            resp = await client.post(
+                f"{self.endpoint}/v1/text_to_image", headers=headers, json=body
+            )
+            if resp.status_code >= 400:
+                raise RuntimeError(
+                    f"Runway text_to_image failed: {_format_error(resp.status_code, resp)}"
+                )
+            task = resp.json()
+            task_id = task.get("id")
+            if not task_id:
+                raise RuntimeError(f"Runway response missing task id: {task}")
+
+            if not options.get("poll", True):
+                return RunwayImageGenDriver._pending_response(
+                    builder, task_id, model, body, task
+                )
+
+            final = await self._poll_until_done(
+                client,
+                task_id,
+                headers=headers,
+                poll_interval=float(options.get("poll_interval", 5)),
+                timeout_seconds=float(options.get("timeout", 600)),
+            )
+
+        return RunwayImageGenDriver._build_success_response(
+            builder, final, model, body, options
+        )
+
+    async def _poll_until_done(
+        self,
+        client: httpx.AsyncClient,
+        task_id: str,
+        *,
+        headers: dict[str, str],
+        poll_interval: float,
+        timeout_seconds: float,
+    ) -> dict[str, Any]:
+        deadline = time.monotonic() + timeout_seconds
+        while True:
+            r = await client.get(
+                f"{self.endpoint}/v1/tasks/{task_id}", headers=headers
+            )
+            if r.status_code >= 400:
+                raise RuntimeError(
+                    f"Runway task poll failed: {_format_error(r.status_code, r)}"
+                )
+            data = r.json()
+            status = data.get("status")
+            if status in _TERMINAL_OK:
+                return data
+            if status in _TERMINAL_FAIL:
+                failure = data.get("failure") or data.get("failureCode") or status
+                raise RuntimeError(f"Runway task {task_id} {status}: {failure}")
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"Runway task {task_id} timed out (status={status})"
+                )
+            await asyncio.sleep(poll_interval)