unique-toolkit 2026.34.0.dev0__tar.gz → 2026.34.0.dev2__tar.gz

{unique_toolkit-2026.34.0.dev0 → unique_toolkit-2026.34.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.34.0.dev0
+Version: 2026.34.0.dev2
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>

{unique_toolkit-2026.34.0.dev0 → unique_toolkit-2026.34.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.34.0.dev0"
+version = "2026.34.0.dev2"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-2026.34.0.dev0 → unique_toolkit-2026.34.0.dev2}/unique_toolkit/agentic_table/service.py

@@ -1,7 +1,8 @@
 import asyncio
 import logging
 import time
-from typing import Any, cast
+from datetime import datetime
+from typing import Any, NamedTuple, cast
 
 from typing_extensions import deprecated
 from unique_sdk import (
@@ -49,6 +50,56 @@ def _sheet_batch_cells_include_row_metadata_from_api(
     return "rowMetadata" in first and isinstance(rm, list)
 
 
+def _artifact_timestamp(value: str) -> datetime:
+    """Parse an artifact ISO-8601 timestamp (e.g. ``2026-07-31T16:26:36.344Z``)."""
+    return datetime.fromisoformat(value.replace("Z", "+00:00"))
+
+
+class _ArtifactBaseline(NamedTuple):
+    """What a sheet's artifacts of one type looked like just before an export of
+    that type was triggered.
+
+    ``ids`` are the records of the type that already existed; ``latest`` is
+    their newest ``updated_at``. Two signals because either can carry the
+    result: a finished report normally arrives as a new record (the trigger's
+    nameless IN_PROGRESS marker and the named report are separate rows), but a
+    re-export can also refresh an existing record in place.
+
+    Kept per artifact type so that triggering one type does not fence out an
+    already-completed export of another type.
+
+    Mirrors the ``_ArtifactBaseline`` used by the SDK CLI's export wait.
+    """
+
+    ids: frozenset[str]
+    latest: datetime | None
+
+
+def _snapshot_artifacts(
+    artifacts: list[MagicTableArtifact],
+    artifact_types: list[MagicTableArtifactType],
+) -> dict[MagicTableArtifactType, _ArtifactBaseline]:
+    baselines: dict[MagicTableArtifactType, _ArtifactBaseline] = {}
+    for artifact_type in artifact_types:
+        records = [a for a in artifacts if a.artifact_type == artifact_type]
+        timestamps = [_artifact_timestamp(a.updated_at) for a in records]
+        baselines[artifact_type] = _ArtifactBaseline(
+            ids=frozenset(a.id for a in records),
+            latest=max(timestamps) if timestamps else None,
+        )
+    return baselines
+
+
+def _is_fresh(artifact: MagicTableArtifact, baseline: _ArtifactBaseline) -> bool:
+    """Whether *artifact* came out of a generation triggered after *baseline*."""
+    if artifact.id not in baseline.ids:
+        return True
+    return (
+        baseline.latest is not None
+        and _artifact_timestamp(artifact.updated_at) > baseline.latest
+    )
+
+
 class LockedAgenticTableError(Exception):
     pass
 
@@ -88,6 +139,9 @@ class AgenticTableService:
         self.table_id = table_id
         self.logger = logger
         self.created_sheet: CreatedMagicTableSheet | None = None
+        # Per-type snapshots taken by generate_artifacts so wait_for_artifacts can
+        # tell a new export apart from records left by earlier generations.
+        self._artifact_baselines: dict[MagicTableArtifactType, _ArtifactBaseline] = {}
 
     @classmethod
     async def create_sheet(
@@ -634,9 +688,17 @@ class AgenticTableService:
         (or poll ``list_artifacts``) to detect completion, then download the artifact's
         ``content_id`` via the Content API.
 
+        Snapshots the sheet's artifacts of the requested types before
+        triggering, so a following ``wait_for_artifacts`` on this instance can
+        tell the new export apart from records left over from earlier
+        generations. Only the requested types' snapshots are replaced; a
+        baseline armed by an earlier trigger for another type is kept, so its
+        completed export stays recognisable.
+
         Raises:
             Exception: If the API reports a non-success status.
         """
+        baselines = _snapshot_artifacts(await self.list_artifacts(), artifact_types)
         result = await AgenticTable.generate_artifact(
             user_id=self._user_id,
             company_id=self._company_id,
@@ -647,6 +709,7 @@ class AgenticTableService:
             raise Exception(
                 result.get("message") or "Failed to trigger artifact generation"
             )
+        self._artifact_baselines.update(baselines)
 
     async def rerun_row(self, row_order: int) -> None:
         """Re-run the agent for a single row (`POST .../row/{rowOrder}/rerun`).
@@ -798,15 +861,26 @@ class AgenticTableService:
     ) -> list[MagicTableArtifact]:
         """Wait until artifacts of the given types are DONE, by polling ``list_artifacts``.
 
-        Artifact records are upserted per type: triggering an export flips the record
-        of that type to IN_PROGRESS and back to DONE when the file is ready. A
-        terminal state is accepted only after IN_PROGRESS has been observed for
-        that artifact type, so a result left over from an earlier generation is
-        not mistaken for the newly triggered one.
-
-        Because the API exposes only the current artifact state, a complete
-        IN_PROGRESS-to-terminal transition between two polls cannot be observed.
-        Keep ``poll_interval`` shorter than the expected minimum generation time.
+        A sheet can hold several records of the same type: the export trigger
+        records a nameless IN_PROGRESS marker that is not always the record the
+        worker completes, so a stale IN_PROGRESS row can sit next to the DONE
+        result, and reports from earlier generations remain listed. Two fences
+        keep the wait from mistaking leftovers for the new export:
+
+        - For a type that ``generate_artifacts`` was called for on this
+          instance, only records that are *fresh* relative to that trigger's
+          snapshot count: a record id that did not exist before, or an
+          ``updated_at`` newer than the snapshot. This also accepts exports
+          that finish before the first poll.
+        - For a type without a snapshot (export triggered elsewhere), a
+          terminal state is accepted only after IN_PROGRESS has been observed
+          for that type, and the newest record (by ``updated_at``) decides the
+          state. This cannot distinguish a result of an earlier generation
+          whose trigger marker is still IN_PROGRESS — prefer triggering and
+          waiting on the same service instance.
+
+        Because the API exposes only the current artifact state, keep
+        ``poll_interval`` shorter than the expected minimum generation time.
 
         Args:
             artifact_types: The artifact types to wait for (as passed to ``generate_artifacts``).
@@ -821,22 +895,41 @@ class AgenticTableService:
             AgenticTableRunTimeoutError: Not all artifacts were DONE within ``timeout``.
         """
         wanted = set(artifact_types)
+        baselines = {
+            artifact_type: baseline
+            for artifact_type, baseline in self._artifact_baselines.items()
+            if artifact_type in wanted
+        }
         started: set[MagicTableArtifactType] = set()
         deadline = time.monotonic() + timeout
         while True:
             artifacts = await self.list_artifacts()
-            current = {
-                a.artifact_type: a for a in artifacts if a.artifact_type in wanted
+            relevant = [a for a in artifacts if a.artifact_type in wanted]
+            candidates: list[MagicTableArtifact] = []
+            for artifact in relevant:
+                baseline = baselines.get(artifact.artifact_type)
+                if baseline is None:
+                    candidates.append(artifact)
+                    if artifact.artifact_state == MagicTableArtifactState.IN_PROGRESS:
+                        started.add(artifact.artifact_type)
+                elif _is_fresh(artifact, baseline):
+                    candidates.append(artifact)
+            gate = started | {
+                a.artifact_type for a in candidates if a.artifact_type in baselines
             }
-            started.update(
-                artifact_type
-                for artifact_type, artifact in current.items()
-                if artifact.artifact_state == MagicTableArtifactState.IN_PROGRESS
-            )
+            # Newest record per type decides the state; older duplicates (e.g. the
+            # stale nameless IN_PROGRESS row from the export trigger) are ignored.
+            current: dict[MagicTableArtifactType, MagicTableArtifact] = {}
+            for artifact in candidates:
+                newest = current.get(artifact.artifact_type)
+                if newest is None or _artifact_timestamp(
+                    artifact.updated_at
+                ) > _artifact_timestamp(newest.updated_at):
+                    current[artifact.artifact_type] = artifact
             failed = [
                 artifact
                 for artifact_type, artifact in current.items()
-                if artifact_type in started
+                if artifact_type in gate
                 and artifact.artifact_state == MagicTableArtifactState.ERROR
             ]
             if failed:
@@ -847,7 +940,7 @@ class AgenticTableService:
             done = {
                 artifact_type: artifact
                 for artifact_type, artifact in current.items()
-                if artifact_type in started
+                if artifact_type in gate
                 and artifact.artifact_state == MagicTableArtifactState.DONE
             }
             if wanted <= set(done.keys()):

{unique_toolkit-2026.34.0.dev0 → unique_toolkit-2026.34.0.dev2}/unique_toolkit/language_model/infos.py

@@ -104,10 +104,12 @@ class LanguageModelName(StrEnum):
     GEMINI_2_5_PRO_EXP_0325 = "litellm:gemini-2-5-pro-exp-03-25"
     GEMINI_2_5_PRO_PREVIEW_0605 = "litellm:gemini-2-5-pro-preview-06-05"
     GEMINI_3_1_PRO_PREVIEW = "litellm:gemini-3-1-pro-preview"
+    GEMINI_3_6_FLASH = "litellm:gemini-3-6-flash"
     GEMINI_3_FLASH_PREVIEW = "litellm:gemini-3-flash-preview"
     GEMINI_3_PRO_PREVIEW = "litellm:gemini-3-pro-preview"
     GROK_4_1_FAST_NON_REASONING = "litellm:grok-4-1-fast-non-reasoning"
     GROK_4_1_FAST_REASONING = "litellm:grok-4-1-fast-reasoning"
+    GROK_4_5 = "litellm:grok-4-5"
     LITELLM_OPENAI_GPT_5 = "litellm:openai-gpt-5"
     LITELLM_OPENAI_GPT_5_MINI = "litellm:openai-gpt-5-mini"
     LITELLM_OPENAI_GPT_5_NANO = "litellm:openai-gpt-5-nano"
@@ -2052,6 +2054,28 @@ class LanguageModelInfo(BaseModel):
                     published_at=date(2026, 1, 19),
                     supported_reasoning_efforts=[],
                 )
+            case LanguageModelName.GEMINI_3_6_FLASH:
+                return cls(
+                    name=model_name,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.VISION,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                        ModelCapabilities.REASONING,
+                        ModelCapabilities.VISION,
+                    ],
+                    provider=LanguageModelProvider.LITELLM,
+                    family=ModelFamily.GOOGLE,
+                    version="gemini-3-6-flash",
+                    encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=1_048_576, token_limit_output=65_536
+                    ),
+                    info_cutoff_at=date(2026, 3, day=1),
+                    published_at=date(2026, 7, 21),
+                    supported_reasoning_efforts=["minimal", "low", "medium", "high"],
+                )
             case LanguageModelName.GEMINI_3_FLASH_PREVIEW:
                 return cls(
                     name=model_name,
@@ -2139,6 +2163,30 @@ class LanguageModelInfo(BaseModel):
                     published_at=date(2025, 11, 19),
                     supported_reasoning_efforts=[],
                 )
+            case LanguageModelName.GROK_4_5:
+                return cls(
+                    name=model_name,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.REASONING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                        ModelCapabilities.VISION,
+                    ],
+                    provider=LanguageModelProvider.LITELLM,
+                    family=ModelFamily.XAI,
+                    version="grok-4-5",
+                    encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with grok tokenizer
+                    token_limits=LanguageModelTokenLimits(
+                        # Context window is 500_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
+                        # Assign 90% for input and 10% for output
+                        token_limit_input=int(480_000 * 0.9),
+                        token_limit_output=int(480_000 * 0.1),
+                    ),
+                    info_cutoff_at=date(2026, 2, day=1),
+                    published_at=date(2026, 7, 16),
+                    supported_reasoning_efforts=["low", "medium", "high"],
+                )
             case LanguageModelName.LITELLM_OPENAI_GPT_5:
                 return cls(
                     name=model_name,