tinyfish 0.2.2__tar.gz → 0.2.4__tar.gz

tinyfish-0.2.4/.pre-commit-config.yaml

@@ -0,0 +1,23 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: check-toml
+      - id: debug-statements
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.5
+    hooks:
+      - id: ruff-check
+      - id: ruff-format
+
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    rev: 0.10.9
+    hooks:
+      - id: uv-lock
+        name: uv-lock
+        files: ^sdk/sdk-python/(uv\.lock|pyproject\.toml)$

tinyfish-0.2.4/CLAUDE.md

@@ -0,0 +1,60 @@
+# TinyFish Python SDK (`tinyfish`)
+
+Official Python SDK for TinyFish. Provides sync (`TinyFish`) and async (`AsyncTinyFish`) clients for running
+automations, streaming events, and managing runs.
+
+For full method reference and examples: see `README.md`.
+
+---
+
+## Package Manager
+
+`uv` — not pip, not poetry.
+
+## Key Entry Points
+
+```
+src/tinyfish/__init__.py    → exports TinyFish, AsyncTinyFish, and all public types
+src/tinyfish/client.py      → TinyFish client class (sync)
+src/tinyfish/agent/         → agent.run(), agent.queue(), agent.stream()
+src/tinyfish/runs/          → runs.get(), runs.list()
+src/tinyfish/_utils/        → HTTP client base (sync + async), retry, error handling
+```
+
+## Quick Usage
+
+```python
+from tinyfish import TinyFish
+
+client = TinyFish(api_key="your-api-key")  # or set TINYFISH_API_KEY env var
+response = client.agent.run(goal="...", url="https://...")
+print(response.result)
+```
+
+## Tests
+
+```bash
+cd sdk/sdk-python && uv run pytest
+```
+
+## Pre-commit Hooks
+
+```bash
+cd sdk/sdk-python && pre-commit install
+```
+
+Hooks: `ruff format`, `ruff check`, `uv-lock` sync. Run before first commit and after any dep change.
+
+## Lint / Format
+
+```bash
+cd sdk/sdk-python && uv run ruff check . && uv run ruff format .
+```
+
+## Package name
+
+`tinyfish` (PyPI). The npm org uses a hyphen: `@tiny-fish/` (not `@tinyfish/`).
+
+## Further Reading
+
+See `README.md` for full usage examples, authentication patterns, and SDK changelog.

tinyfish-0.2.4/PKG-INFO

@@ -0,0 +1,344 @@
+Metadata-Version: 2.4
+Name: tinyfish
+Version: 0.2.4
+Summary: Official Python SDK for the TinyFish API
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: tenacity>=8.0.0
+Description-Content-Type: text/markdown
+
+# TinyFish Python SDK
+
+The official Python SDK for [TinyFish](https://agent.tinyfish.ai)
+
+## Installation
+
+```bash
+pip install tinyfish
+```
+
+Requires Python 3.11+.
+
+## Get your API key
+
+Sign up and grab your key at [agent.tinyfish.ai/api-keys](https://agent.tinyfish.ai/api-keys).
+
+## Quickstart
+
+```python
+from tinyfish import TinyFish
+
+client = TinyFish(api_key="your-api-key")
+
+response = client.agent.run(
+    goal="What is the current Bitcoin price?",
+    url="https://www.coinbase.com/price/bitcoin",
+)
+print(response.result)
+```
+
+Or set the `TINYFISH_API_KEY` environment variable and omit `api_key`:
+
+```python
+client = TinyFish()
+```
+
+## Methods
+
+Every method below is available on both `TinyFish` (sync) and `AsyncTinyFish` (async). Async versions have the same signatures — just `await` them.
+
+| Method | Description | Returns | Blocks? |
+|--------|-------------|---------|---------|
+| [`agent.run()`](#agentrun--block-until-done) | Run an automation, wait for the result | `AgentRunResponse` | Yes |
+| [`agent.queue()`](#agentqueue--fire-and-forget) | Start an automation, return immediately | `AgentRunAsyncResponse` | No |
+| [`agent.stream()`](#agentstream--real-time-events) | Stream live SSE events as the agent works | `AgentStream` | No |
+| [`runs.get()`](#runsget--retrieve-a-single-run) | Retrieve a single run by ID | `Run` | — |
+| [`runs.list()`](#runslist--list-and-filter-runs) | List runs with filtering, sorting, pagination | `RunListResponse` | — |
+
+---
+
+### `agent.run()` — block until done
+
+Sends the automation and waits for it to finish. Returns the full result in one shot.
+
+```python
+from tinyfish import TinyFish, RunStatus, BrowserProfile, ProxyConfig, ProxyCountryCode
+
+client = TinyFish()
+
+response = client.agent.run(
+    goal="Extract the top 5 headlines",              # required — what to do on the page
+    url="https://news.ycombinator.com",              # required — URL to open
+    browser_profile=BrowserProfile.STEALTH,          # optional — "lite" (default) or "stealth"
+    proxy_config=ProxyConfig(                        # optional — proxy settings
+        enabled=True,
+        country_code=ProxyCountryCode.US,            # optional — US, GB, CA, DE, FR, JP, AU
+    ),
+)
+
+if response.status == RunStatus.COMPLETED:
+    print(response.result)
+else:
+    print(f"Failed: {response.error.message}")
+```
+
+**Returns `AgentRunResponse`:**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `status` | `RunStatus` | `COMPLETED`, `FAILED`, etc. |
+| `run_id` | `str \| None` | Unique run identifier |
+| `result` | `dict \| None` | Extracted data (`None` if failed) |
+| `error` | `RunError \| None` | Error details (`None` if succeeded) |
+| `num_of_steps` | `int` | Number of steps the agent took |
+| `started_at` | `datetime \| None` | When the run started |
+| `finished_at` | `datetime \| None` | When the run finished |
+
+---
+
+### `agent.queue()` — fire and forget
+
+Starts the automation in the background and returns a `run_id` immediately. Poll with `runs.get()` when you're ready for the result.
+
+```python
+import time
+from tinyfish import TinyFish, RunStatus
+
+client = TinyFish()
+
+queued = client.agent.queue(
+    goal="Extract the top 5 headlines",              # required — what to do on the page
+    url="https://news.ycombinator.com",              # required — URL to open
+    browser_profile=None,                            # optional — "lite" (default) or "stealth"
+    proxy_config=None,                               # optional — proxy settings
+)
+print(f"Run started: {queued.run_id}")
+
+# Poll for completion
+while True:
+    run = client.runs.get(queued.run_id)
+    if run.status in (RunStatus.COMPLETED, RunStatus.FAILED):
+        break
+    time.sleep(5)
+
+print(run.result)
+```
+
+**Returns `AgentRunAsyncResponse`:**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `run_id` | `str \| None` | Run ID to poll with `runs.get()` |
+| `error` | `RunError \| None` | Error if queuing itself failed |
+
+---
+
+### `agent.stream()` — real-time events
+
+Opens a Server-Sent Events stream. You get live progress updates as the agent works, plus a WebSocket URL for a live browser preview.
+
+```python
+from tinyfish import TinyFish, CompleteEvent, ProgressEvent
+
+client = TinyFish()
+
+with client.agent.stream(
+    goal="Extract the top 5 headlines",              # required — what to do on the page
+    url="https://news.ycombinator.com",              # required — URL to open
+    browser_profile=None,                            # optional — "lite" (default) or "stealth"
+    proxy_config=None,                               # optional — proxy settings
+    on_started=lambda e: print(f"Started: {e.run_id}"),          # optional — called when run starts
+    on_streaming_url=lambda e: print(f"Watch: {e.streaming_url}"),  # optional — called with live browser URL
+    on_progress=lambda e: print(f"  > {e.purpose}"),             # optional — called on each step
+    on_heartbeat=lambda e: None,                                 # optional — called on keepalive pings
+    on_complete=lambda e: print(f"Done: {e.status}"),            # optional — called when run finishes
+) as stream:
+    for event in stream:
+        # Callbacks fire automatically during iteration.
+        # You can also inspect events directly:
+        if isinstance(event, CompleteEvent):
+            print(event.result_json)
+```
+
+**Returns `AgentStream`** — a context manager you iterate over. Events arrive in order: `STARTED` → `STREAMING_URL` → `PROGRESS` (repeated) → `COMPLETE`.
+
+See the [Streaming Guide](docs/streaming-guide.md) for the full event lifecycle, event types, and advanced patterns.
+
+---
+
+### `runs.get()` — retrieve a single run
+
+Fetch the full details of a run by its ID.
+
+```python
+run = client.runs.get(
+    "run_abc123",   # required — the run ID
+)
+
+print(run.status)   # PENDING, RUNNING, COMPLETED, FAILED, CANCELLED
+print(run.result)
+print(run.goal)
+print(run.streaming_url)          # live browser URL (while RUNNING)
+print(run.browser_config)         # proxy/browser settings that were used
+```
+
+**Returns `Run`:**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `run_id` | `str` | Unique identifier |
+| `status` | `RunStatus` | `PENDING`, `RUNNING`, `COMPLETED`, `FAILED`, `CANCELLED` |
+| `goal` | `str` | The goal that was given |
+| `result` | `dict \| None` | Extracted data (`None` if not completed) |
+| `error` | `RunError \| None` | Error details (`None` if succeeded) |
+| `streaming_url` | `str \| None` | Live browser URL (available while running) |
+| `browser_config` | `BrowserConfig \| None` | Proxy/browser settings used |
+| `created_at` | `datetime` | When the run was created |
+| `started_at` | `datetime \| None` | When execution started |
+| `finished_at` | `datetime \| None` | When execution finished |
+
+**Raises:** `ValueError` if `run_id` is empty. `NotFoundError` if no run exists with that ID.
+
+---
+
+### `runs.list()` — list and filter runs
+
+List runs with optional filtering, sorting, and cursor-based pagination. All parameters are optional.
+
+```python
+from tinyfish import RunStatus, SortDirection
+
+response = client.runs.list(
+    status=RunStatus.COMPLETED,                      # optional — filter by status
+    goal="headlines",                                # optional — filter by goal text
+    created_after="2025-01-01T00:00:00Z",            # optional — ISO 8601 lower bound
+    created_before="2025-12-31T23:59:59Z",           # optional — ISO 8601 upper bound
+    sort_direction=SortDirection.DESC,                # optional — "asc" or "desc"
+    limit=10,                                        # optional — max runs per page
+    cursor=None,                                     # optional — pagination cursor from previous response
+)
+
+for run in response.data:
+    print(f"{run.run_id} | {run.goal}")
+
+# Pagination
+if response.pagination.has_more:
+    next_page = client.runs.list(cursor=response.pagination.next_cursor)
+```
+
+**Returns `RunListResponse`:**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `data` | `list[Run]` | List of runs |
+| `pagination.total` | `int` | Total runs matching filters |
+| `pagination.has_more` | `bool` | Whether more pages exist |
+| `pagination.next_cursor` | `str \| None` | Pass to `cursor=` for the next page |
+
+See the [Pagination Guide](docs/pagination-guide.md) for full pagination loop examples.
+
+---
+
+## Sync vs Async
+
+Use `AsyncTinyFish` when you're in an async context (FastAPI, aiohttp, etc.):
+
+**Sync:**
+
+```python
+from tinyfish import TinyFish
+
+client = TinyFish()
+response = client.agent.run(goal="...", url="...")
+```
+
+**Async:**
+
+```python
+from tinyfish import AsyncTinyFish
+
+client = AsyncTinyFish()
+response = await client.agent.run(goal="...", url="...")
+```
+
+All five methods (`agent.run()`, `agent.queue()`, `agent.stream()`, `runs.get()`, `runs.list()`) work the same way — same parameters, just `await`-ed.
+
+## Configuration
+
+### Client options
+
+```python
+client = TinyFish(
+    api_key="your-api-key",         # optional — or set TINYFISH_API_KEY env var
+    base_url="https://agent.tinyfish.ai",  # optional — default shown
+    timeout=600.0,                  # optional — seconds (default: 600)
+    max_retries=2,                  # optional — retry attempts (default: 2)
+)
+```
+
+The SDK retries `408`, `429`, and `5xx` errors automatically with exponential backoff (0.5s multiplier, max 8s wait).
+
+### Browser profiles
+
+Control the browser environment with `browser_profile`:
+
+- **`lite`** (default) — fast, lightweight. Good for most sites.
+- **`stealth`** — anti-detection mode. Use for sites with bot protection.
+
+```python
+from tinyfish import BrowserProfile
+
+response = client.agent.run(
+    goal="...",
+    url="...",
+    browser_profile=BrowserProfile.STEALTH,
+)
+```
+
+### Proxy configuration
+
+Route requests through a proxy, optionally pinned to a country:
+
+```python
+from tinyfish import ProxyConfig, ProxyCountryCode
+
+response = client.agent.run(
+    goal="...",
+    url="...",
+    proxy_config=ProxyConfig(enabled=True, country_code=ProxyCountryCode.US),
+)
+```
+
+Available countries: `US`, `GB`, `CA`, `DE`, `FR`, `JP`, `AU`.
+
+See the [Proxy & Browser Profiles Guide](docs/proxy-and-browser-profiles.md) for more details.
+
+## Error handling
+
+```python
+from tinyfish import TinyFish, AuthenticationError, RateLimitError, SDKError
+
+client = TinyFish()
+
+try:
+    response = client.agent.run(goal="...", url="...")
+except AuthenticationError:
+    print("Invalid API key")
+except RateLimitError:
+    print("Rate limited (retries exhausted)")
+except SDKError:
+    print("Something else went wrong")
+```
+
+The SDK automatically retries transient errors (`408`, `429`, `5xx`) up to `max_retries` times with exponential backoff. Non-retryable errors (`401`, `400`, `404`) raise immediately.
+
+For the full exception hierarchy and internal architecture, see [docs/internal/exceptions-and-errors-guide.md](docs/internal/exceptions-and-errors-guide.md).
+
+## Guides
+
+- [Streaming Guide](docs/streaming-guide.md) — event lifecycle, callbacks vs iteration, event type reference
+- [Proxy & Browser Profiles](docs/proxy-and-browser-profiles.md) — stealth mode, proxy countries
+- [Pagination Guide](docs/pagination-guide.md) — filtering, sorting, cursor-based pagination
+- [Exceptions & Error Handling (internal)](docs/internal/exceptions-and-errors-guide.md) — layer-by-layer architecture
+- [Testing Guide](tests/testing_guide.md) — running and writing tests

tinyfish-0.2.4/docs/internal/api-integration-header.md

@@ -0,0 +1,58 @@
+# API Integration Tagging (`TF_API_INTEGRATION`)
+
+Internal-only mechanism for identifying which integration platform is making API requests through our SDK.
+
+## How it works
+
+The SDK reads the `TF_API_INTEGRATION` environment variable when building request bodies. When set, the SDK injects `api_integration` into every request body sent to the automation endpoints.
+
+```text
+TF_API_INTEGRATION=n8n  -->  { "goal": "...", "url": "...", "api_integration": "n8n" }
+```
+
+This reuses the existing `api_integration` body field that the server already parses, stores in the DB, and emits to PostHog — no backend changes needed.
+
+This is intentionally **not** exposed as a constructor parameter or public API. It does not appear in editor autocomplete, type definitions, or documentation. Only we control which integrations set this value.
+
+## Environment variable
+
+| Variable              | Example values         | Required |
+| --------------------- | ---------------------- | -------- |
+| `TF_API_INTEGRATION`  | `n8n`, `dify`, `zapier` | No       |
+
+When unset or empty, `api_integration` is omitted from the body. Existing behavior is unchanged.
+
+## Where it's read
+
+`src/tinyfish/_utils/client/_base.py` — `_inject_integration()`, called from `_request()` in both sync and async clients:
+
+```python
+integration = os.environ.get("TF_API_INTEGRATION", "").strip()
+if integration:
+    json["api_integration"] = integration
+```
+
+This runs on every API request automatically — no per-resource setup needed.
+
+## Server-side flow
+
+1. Server validates `api_integration` via Zod schema (`frontend/app/v1/schemas.ts`)
+2. `buildRunOptions()` extracts it from the request body
+3. Stored in `runs.api_integration` DB column
+4. Emitted on `run_completed` PostHog event as `api_integration` property
+
+## Setting up a new integration
+
+To tag requests from a new integration partner:
+
+1. Set `TF_API_INTEGRATION=<name>` in the environment where the SDK runs (e.g., the n8n node, Dify plugin, Zapier action)
+2. No SDK code changes needed — the env var is picked up automatically
+3. The value will appear in PostHog under `run_completed.api_integration`
+
+## Tests
+
+`tests/test_client.py`:
+
+- `test_integration_in_body_via_env` — `api_integration` is in the request body when env var is set
+- `test_no_integration_in_body_by_default` — `api_integration` is absent when env var is not set
+- `test_async_integration_in_body_via_env` — async client variant

{tinyfish-0.2.2 → tinyfish-0.2.4}/pyproject.toml

@@ -1,7 +1,8 @@
 [project]
 name = "tinyfish"
-version = "0.2.2"
+version = "0.2.4"
 description = "Official Python SDK for the TinyFish API"
+readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "httpx>=0.27.0",
@@ -32,6 +33,10 @@ asyncio_default_fixture_loop_scope = "session"
 [tool.ruff]
 src = ["src"]
 line-length = 120
+[tool.ruff.format]
+quote-style = "double"
+docstring-code-format = true
+docstring-code-line-length = 20
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "PYI", "TID"]

{tinyfish-0.2.2 → tinyfish-0.2.4}/src/tinyfish/_utils/client/_base.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import os
 from importlib.metadata import version as _pkg_version
-from typing import TypeVar
+from typing import Any, TypeVar
 
 import httpx
 from pydantic import BaseModel
@@ -79,8 +79,19 @@ class _BaseClient:
             "Accept": "application/json",
             "X-API-Key": self._api_key,
             "User-Agent": f"tinyfish-python/{_pkg_version('tinyfish')}",
+            "X-TF-Request-Origin": "tinyfish-python",
         }
 
+    @staticmethod
+    def _inject_integration(json: dict[str, Any] | None) -> dict[str, Any] | None:
+        """Inject api_integration from TF_API_INTEGRATION env var into JSON body."""
+        if json is None:
+            return None
+        integration = os.environ.get("TF_API_INTEGRATION", "").strip()
+        if integration:
+            json["api_integration"] = integration
+        return json
+
     def _make_status_error(self, response: httpx.Response) -> APIStatusError:
         """
         Translate an error HTTP response into the appropriate SDK exception.

{tinyfish-0.2.2 → tinyfish-0.2.4}/src/tinyfish/_utils/client/async_.py

@@ -72,6 +72,7 @@ class BaseAsyncAPIClient(_BaseClient):
             APIConnectionError: Network/connection error
             APIStatusError: HTTP error status (4xx, 5xx)
         """
+        json = self._inject_integration(json)
         max_attempts = self._max_retries + 1
 
         # Retryable: 408, 429, 5xx, and network errors (TimeoutException ⊂ RequestError).
@@ -142,6 +143,7 @@ class BaseAsyncAPIClient(_BaseClient):
         matching the retry behaviour of ``_request()``. Once a 200 response
         is received and streaming begins, no further retries are attempted.
         """
+        json = self._inject_integration(json)
         max_attempts = self._max_retries + 1
 
         @retry(

{tinyfish-0.2.2 → tinyfish-0.2.4}/src/tinyfish/_utils/client/sync.py

@@ -72,6 +72,7 @@ class BaseSyncAPIClient(_BaseClient):
             APIConnectionError: Network/connection error
             APIStatusError: HTTP error status (4xx, 5xx)
         """
+        json = self._inject_integration(json)
         max_attempts = self._max_retries + 1
 
         # Retryable: 408, 429, 5xx, and network errors (TimeoutException ⊂ RequestError).
@@ -142,6 +143,7 @@ class BaseSyncAPIClient(_BaseClient):
         matching the retry behaviour of ``_request()``. Once a 200 response
         is received and streaming begins, no further retries are attempted.
         """
+        json = self._inject_integration(json)
         max_attempts = self._max_retries + 1
 
         @retry(

{tinyfish-0.2.2 → tinyfish-0.2.4}/src/tinyfish/agent/__init__.py

@@ -41,8 +41,15 @@ class AgentStream:
 
     Use as::
 
-        with client.agent.stream(goal=..., url=...) as stream:
-            for event in stream:
+        with (
+            client.agent.stream(
+                goal=...,
+                url=...,
+            ) as stream
+        ):
+            for (
+                event
+            ) in stream:
                 ...
     """
 
@@ -64,8 +71,15 @@ class AsyncAgentStream:
 
     Use as::
 
-        async with client.agent.stream(goal=..., url=...) as stream:
-            async for event in stream:
+        async with (
+            client.agent.stream(
+                goal=...,
+                url=...,
+            ) as stream
+        ):
+            async for (
+                event
+            ) in stream:
                 ...
     """
 
@@ -166,10 +180,22 @@ class AgentResource(BaseSyncAPIResource):
         Use the on_* callbacks for a reactive style, or iterate over
         the stream for a sequential style::
 
-            with client.agent.stream(goal=..., url=...) as stream:
-                for event in stream:
-                    if isinstance(event, ProgressEvent):
-                        print(event.purpose)
+            with (
+                client.agent.stream(
+                    goal=...,
+                    url=...,
+                ) as stream
+            ):
+                for (
+                    event
+                ) in stream:
+                    if isinstance(
+                        event,
+                        ProgressEvent,
+                    ):
+                        print(
+                            event.purpose
+                        )
 
         Args:
             goal: Natural language description of what to do on the page.
@@ -309,10 +335,22 @@ class AsyncAgentResource(BaseAsyncAPIResource):
         Use the on_* callbacks for a reactive style, or iterate over
         the stream for a sequential style::
 
-            async with client.agent.stream(goal=..., url=...) as stream:
-                async for event in stream:
-                    if isinstance(event, ProgressEvent):
-                        print(event.purpose)
+            async with (
+                client.agent.stream(
+                    goal=...,
+                    url=...,
+                ) as stream
+            ):
+                async for (
+                    event
+                ) in stream:
+                    if isinstance(
+                        event,
+                        ProgressEvent,
+                    ):
+                        print(
+                            event.purpose
+                        )
 
         Args:
             goal: Natural language description of what to do on the page.

{tinyfish-0.2.2 → tinyfish-0.2.4}/src/tinyfish/agent/types.py

@@ -67,12 +67,19 @@ class AgentRunResponse(BaseModel):
         ```python
         response = client.agent.run(
             goal="Find the price of iPhone 15",
-            url="https://www.apple.com"
+            url="https://www.apple.com",
         )
-        if response.status == "COMPLETED":
-            print(response.result)
+        if (
+            response.status
+            == "COMPLETED"
+        ):
+            print(
+                response.result
+            )
         else:
-            print(f"Failed: {response.error.message}")
+            print(
+                f"Failed: {response.error.message}"
+            )
         ```
     """
 
@@ -103,13 +110,19 @@ class AgentRunAsyncResponse(BaseModel):
         ```python
         response = client.agent.queue(
             goal="Extract product details",
-            url="https://example.com"
+            url="https://example.com",
+        )
+        print(
+            f"Run started: {response.run_id}"
         )
-        print(f"Run started: {response.run_id}")
 
         # Check status later
-        run = client.runs.get(response.run_id)
-        print(f"Status: {run.status}")
+        run = client.runs.get(
+            response.run_id
+        )
+        print(
+            f"Status: {run.status}"
+        )
         ```
     """
 

{tinyfish-0.2.2 → tinyfish-0.2.4}/tests/test_client.py

@@ -184,3 +184,46 @@ def test_repr_short_key():
     r = repr(c)
     assert "****" in r
     assert "short" not in r
+
+
+# ─── TF_API_INTEGRATION env var ───────────────────────────────────────────
+
+
+# TF_API_INTEGRATION env var injects api_integration into request body
+@pytest.mark.respx(base_url=BASE_URL)
+def test_integration_in_body_via_env(respx_mock: MockRouter):
+    with mock.patch.dict(os.environ, {"TF_API_INTEGRATION": "n8n"}):
+        c = TinyFish(api_key=API_KEY, base_url=BASE_URL, max_retries=0)
+        route = respx_mock.post(_PATH).mock(return_value=httpx.Response(200, json=_RUN_OK))
+        c.agent.run(**_BODY)
+    import json
+
+    body = json.loads(route.calls[0].request.content)
+    assert body["api_integration"] == "n8n"
+
+
+# Without TF_API_INTEGRATION, api_integration is not in request body
+@pytest.mark.respx(base_url=BASE_URL)
+def test_no_integration_in_body_by_default(respx_mock: MockRouter):
+    with mock.patch.dict(os.environ, {}, clear=False):
+        os.environ.pop("TF_API_INTEGRATION", None)
+        c = TinyFish(api_key=API_KEY, base_url=BASE_URL, max_retries=0)
+        route = respx_mock.post(_PATH).mock(return_value=httpx.Response(200, json=_RUN_OK))
+        c.agent.run(**_BODY)
+    import json
+
+    body = json.loads(route.calls[0].request.content)
+    assert "api_integration" not in body
+
+
+# Async client injects api_integration into request body when env var is set
+@pytest.mark.respx(base_url=BASE_URL)
+async def test_async_integration_in_body_via_env(respx_mock: MockRouter):
+    with mock.patch.dict(os.environ, {"TF_API_INTEGRATION": "dify"}):
+        route = respx_mock.post(_PATH).mock(return_value=httpx.Response(200, json=_RUN_OK))
+        async with AsyncTinyFish(api_key=API_KEY, base_url=BASE_URL, max_retries=0) as c:
+            await c.agent.run(**_BODY)
+    import json
+
+    body = json.loads(route.calls[0].request.content)
+    assert body["api_integration"] == "dify"

{tinyfish-0.2.2 → tinyfish-0.2.4}/uv.lock

@@ -322,7 +322,7 @@ wheels = [
 
 [[package]]
 name = "tinyfish"
-version = "0.2.2"
+version = "0.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

tinyfish-0.2.2/PKG-INFO

@@ -1,8 +0,0 @@
-Metadata-Version: 2.4
-Name: tinyfish
-Version: 0.2.2
-Summary: Official Python SDK for the TinyFish API
-Requires-Python: >=3.11
-Requires-Dist: httpx>=0.27.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: tenacity>=8.0.0