unique_toolkit 1.77.1__tar.gz → 1.77.3__tar.gz

{unique_toolkit-1.77.1 → unique_toolkit-1.77.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 1.77.1
+Version: 1.77.3
 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-1.77.1 → unique_toolkit-1.77.3}/pyproject.toml

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

{unique_toolkit-1.77.1 → unique_toolkit-1.77.3}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/generated_files.py

@@ -358,7 +358,6 @@ class DisplayCodeInterpreterFilesPostProcessor(
             logger, {"chat_id": chat_id or "n/a"}
         )
 
-        self._orphan_code_blocks: list[CodeInterpreterBlock] = []
         self._short_term_memory_manager = None
         if chat_id is not None and user_id is not None and company_id is not None:
             self._short_term_memory_manager = _init_short_term_memory_manager(
@@ -465,34 +464,11 @@ class DisplayCodeInterpreterFilesPostProcessor(
             )
         save_ms = (time.monotonic() - phase_t0) * 1000
 
-        phase_t0 = time.monotonic()
-        try:
-            if feature_flags.enable_code_execution_fence_un_17972.is_enabled(
-                self._company_id
-            ):
-                self._orphan_code_blocks = await self._upload_orphan_code_as_txt(
-                    loop_response
-                )
-                if self._orphan_code_blocks:
-                    self._log.info(
-                        "run() produced %d orphan code block(s)",
-                        len(self._orphan_code_blocks),
-                    )
-            else:
-                self._orphan_code_blocks = []
-        except Exception:
-            self._log.exception(
-                "run() failed to process orphan code blocks; "
-                "file replacement will still proceed."
-            )
-            self._orphan_code_blocks = []
-        orphan_ms = (time.monotonic() - phase_t0) * 1000
-
         total_ms = (time.monotonic() - run_t0) * 1000
         self._log.info(
             "run() finished — content_map has %d entries (%d ok, %d failed). "
             "Timing: total=%.0fms, load_stm=%.0fms, download_upload=%.0fms, "
-            "save_stm=%.0fms, orphan=%.0fms",
+            "save_stm=%.0fms",
             len(self._content_map),
             len(succeeded),
             len(failed),
@@ -500,7 +476,6 @@ class DisplayCodeInterpreterFilesPostProcessor(
             load_ms,
             download_upload_ms,
             save_ms,
-            orphan_ms,
         )
 
     @override
@@ -624,25 +599,6 @@ class DisplayCodeInterpreterFilesPostProcessor(
             if fences_changed:
                 self._log.info("Fence injection modified the message text")
 
-            if self._orphan_code_blocks:
-                for block in self._orphan_code_blocks:
-                    for file in block.files:
-                        loop_response.message.references.append(
-                            ContentReference(
-                                sequence_number=ref_number,
-                                source_id=file.content_id,
-                                source="node-ingestion-chunks",
-                                url=f"unique://content/{file.content_id}",
-                                name=file.filename,
-                            )
-                        )
-                        ref_number += 1
-                changed = True
-                self._log.info(
-                    "Added %d orphan code block(s) to message references",
-                    len(self._orphan_code_blocks),
-                )
-
         _warn_missing_content_ids(loop_response.message.text or "", self._content_map)
         loop_response.message.text, dangling_replaced = _replace_dangling_sandbox_links(
             loop_response.message.text
@@ -963,74 +919,6 @@ class DisplayCodeInterpreterFilesPostProcessor(
             (time.monotonic() - t0) * 1000,
         )
 
-    async def _upload_orphan_code_as_txt(
-        self, loop_response: ResponsesLanguageModelStreamResponse
-    ) -> list[CodeInterpreterBlock]:
-        """Upload source **code** from calls that produced no container files as .txt artifacts.
-
-        When code interpreter runs but generates no files or images, the response
-        text has no sandbox links for fence injection to hook onto.  This method
-        converts those "orphan" calls into downloadable .txt files (the executed
-        code, not stdout) so the postprocessor can attach a reference for download.
-
-        Called only when the fence feature flag is enabled.  Skipped entirely if
-        any container files were produced (normal fencing handles those).
-        """
-        if loop_response.container_files:
-            return []
-
-        calls = loop_response.code_interpreter_calls
-        if not calls:
-            return []
-
-        assert self._chat_service is not None  # Checked in __init__
-
-        use_numeric_suffix = len(calls) > 1
-        orphan_blocks: list[CodeInterpreterBlock] = []
-
-        for i, call in enumerate(calls):
-            if not call.code:
-                continue
-
-            # Always persist the executed source as the downloadable .txt (not stdout),
-            # so the attachment matches what ran in the sandbox.
-            txt_content = call.code
-            filename = f"code_{i + 1}.txt" if use_numeric_suffix else "code.txt"
-
-            try:
-                content = await self._build_retry()(
-                    self._chat_service.upload_to_chat_from_bytes_async,
-                    content=txt_content.encode("utf-8"),
-                    content_name=filename,
-                    mime_type="text/plain",
-                    skip_ingestion=True,
-                    hide_in_chat=True,
-                )
-            except Exception:
-                self._log.exception(
-                    "Failed to upload orphan code block as txt for call %d ('%s'); "
-                    "falling back to legacy code block display.",
-                    i,
-                    filename,
-                )
-                continue
-
-            orphan_file = CodeInterpreterFile(
-                filename=filename,
-                content_id=content.id,
-                type="document",
-            )
-            orphan_blocks.append(
-                CodeInterpreterBlock(code=call.code, files=[orphan_file])
-            )
-            self._log.info(
-                "Uploaded orphan code block as '%s' (content_id=%s)",
-                filename,
-                content.id,
-            )
-
-        return orphan_blocks
-
 
 def _get_file_type(filename: str) -> CodeInterpreterFileType:
     mime = guess_type(filename)[0] or ""

unique_toolkit-1.77.3/unique_toolkit/experimental/__init__.py

@@ -0,0 +1,23 @@
+"""``unique_toolkit.experimental`` — opt-in surface for experimental services.
+
+.. warning::
+
+    Anything exported from this subpackage is **experimental**. The public API,
+    method names, argument shapes, and return types may change at any time and
+    are **not** covered by the toolkit's normal stability guarantees. Pin the
+    toolkit version if you depend on a specific shape.
+
+Currently exposes:
+
+- :class:`unique_toolkit.experimental.scheduled_task.ScheduledTasks` — cron-based
+  scheduled tasks that trigger assistants on a recurring schedule (wrapper over
+  :class:`unique_sdk.ScheduledTask`).
+"""
+
+from unique_toolkit.experimental.scheduled_task import (
+    ScheduledTasks as ScheduledTasks,
+)
+
+__all__ = [
+    "ScheduledTasks",
+]

unique_toolkit-1.77.3/unique_toolkit/experimental/scheduled_task/__init__.py

@@ -0,0 +1,71 @@
+"""``unique_toolkit.experimental.scheduled_task`` — cron-based assistant triggers.
+
+.. warning::
+
+    **Experimental.** This subpackage is exposed under
+    :mod:`unique_toolkit.experimental` and its public API may change without
+    notice. It is not covered by the toolkit's normal stability guarantees.
+
+A thin, typed wrapper around :class:`unique_sdk.ScheduledTask`. The single
+entry point is :class:`ScheduledTasks`; the subpackage also re-exports the
+Pydantic schemas used on responses, plus a :class:`Cron` ``StrEnum`` of
+ready-made cron strings for the most common schedules.
+"""
+
+from unique_toolkit.experimental.scheduled_task.cron import Cron as Cron
+from unique_toolkit.experimental.scheduled_task.functions import (
+    create_scheduled_task as create_scheduled_task,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    create_scheduled_task_async as create_scheduled_task_async,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    delete_scheduled_task as delete_scheduled_task,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    delete_scheduled_task_async as delete_scheduled_task_async,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    get_scheduled_task as get_scheduled_task,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    get_scheduled_task_async as get_scheduled_task_async,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    list_scheduled_tasks as list_scheduled_tasks,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    list_scheduled_tasks_async as list_scheduled_tasks_async,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    update_scheduled_task as update_scheduled_task,
+)
+from unique_toolkit.experimental.scheduled_task.functions import (
+    update_scheduled_task_async as update_scheduled_task_async,
+)
+from unique_toolkit.experimental.scheduled_task.schemas import (
+    DeletedScheduledTask as DeletedScheduledTask,
+)
+from unique_toolkit.experimental.scheduled_task.schemas import (
+    ScheduledTask as ScheduledTask,
+)
+from unique_toolkit.experimental.scheduled_task.service import (
+    ScheduledTasks as ScheduledTasks,
+)
+
+__all__ = [
+    "Cron",
+    "DeletedScheduledTask",
+    "ScheduledTask",
+    "ScheduledTasks",
+    "create_scheduled_task",
+    "create_scheduled_task_async",
+    "delete_scheduled_task",
+    "delete_scheduled_task_async",
+    "get_scheduled_task",
+    "get_scheduled_task_async",
+    "list_scheduled_tasks",
+    "list_scheduled_tasks_async",
+    "update_scheduled_task",
+    "update_scheduled_task_async",
+]

unique_toolkit-1.77.3/unique_toolkit/experimental/scheduled_task/cron.py

@@ -0,0 +1,90 @@
+"""Convenience catalogue of 5-field (UTC) cron strings for scheduled tasks.
+
+The server stores schedules as plain cron strings. :class:`Cron` is a
+:class:`~enum.StrEnum` of the most common schedules — every member *is* a
+``str``, so you can drop it straight into :meth:`ScheduledTasks.create`
+without any conversion. For schedules that aren't covered, pass a raw cron
+string.
+
+.. note::
+
+    All expressions are interpreted in **UTC** by the server.
+
+.. warning::
+
+    **Experimental.** Ships under :mod:`unique_toolkit.experimental`. API may
+    change without notice.
+
+Example
+-------
+
+    >>> from unique_toolkit.experimental.scheduled_task import Cron
+    >>> Cron.DAILY_MIDNIGHT
+    <Cron.DAILY_MIDNIGHT: '0 0 * * *'>
+    >>> str(Cron.DAILY_MIDNIGHT)
+    '0 0 * * *'
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class Cron(StrEnum):
+    """Named ready-made 5-field cron expressions (UTC).
+
+    Each member is a ``str`` subclass, so instances can be passed straight
+    through to anything expecting a cron string — including
+    :meth:`ScheduledTasks.create`.
+    """
+
+    EVERY_MINUTE = "* * * * *"
+    """Fires every minute."""
+
+    EVERY_FIVE_MINUTES = "*/5 * * * *"
+    """Fires every 5 minutes."""
+
+    EVERY_FIFTEEN_MINUTES = "*/15 * * * *"
+    """Fires every 15 minutes."""
+
+    EVERY_THIRTY_MINUTES = "*/30 * * * *"
+    """Fires every 30 minutes."""
+
+    HOURLY = "0 * * * *"
+    """Fires once an hour on the hour (``:00``)."""
+
+    DAILY_MIDNIGHT = "0 0 * * *"
+    """Fires once a day at 00:00 UTC."""
+
+    DAILY_NOON = "0 12 * * *"
+    """Fires once a day at 12:00 UTC."""
+
+    DAILY_9AM = "0 9 * * *"
+    """Fires once a day at 09:00 UTC."""
+
+    WEEKDAYS_9AM = "0 9 * * 1-5"
+    """Fires on weekdays (Mon-Fri) at 09:00 UTC."""
+
+    WEEKDAYS_MIDNIGHT = "0 0 * * 1-5"
+    """Fires on weekdays (Mon-Fri) at 00:00 UTC."""
+
+    WEEKENDS_MIDNIGHT = "0 0 * * 0,6"
+    """Fires on weekends (Sat & Sun) at 00:00 UTC."""
+
+    WEEKLY_SUNDAY_MIDNIGHT = "0 0 * * 0"
+    """Fires every Sunday at 00:00 UTC."""
+
+    WEEKLY_MONDAY_MIDNIGHT = "0 0 * * 1"
+    """Fires every Monday at 00:00 UTC."""
+
+    MONTHLY_FIRST_MIDNIGHT = "0 0 1 * *"
+    """Fires on the 1st of every month at 00:00 UTC."""
+
+    MONTHLY_FIFTEENTH_MIDNIGHT = "0 0 15 * *"
+    """Fires on the 15th of every month at 00:00 UTC."""
+
+    YEARLY_JAN_FIRST = "0 0 1 1 *"
+    """Fires on January 1st at 00:00 UTC."""
+
+
+__all__ = ["Cron"]

unique_toolkit-1.77.3/unique_toolkit/experimental/scheduled_task/functions.py

@@ -0,0 +1,311 @@
+"""Low-level function wrappers around :class:`unique_sdk.ScheduledTask`.
+
+Each SDK operation gets a ``<verb>`` and ``<verb>_async`` pair. The functions
+take ``user_id`` and ``company_id`` as the first two positional arguments (the
+acting user's credentials) and return toolkit Pydantic models — SDK
+``TypedDict``\\s never leak out of this module.
+
+Notes on update semantics
+-------------------------
+
+:func:`update_scheduled_task` / :func:`update_scheduled_task_async` support two
+mutually-exclusive intents for :attr:`chat_id`:
+
+- Pass ``chat_id="chat_…"`` to repoint the task at a different chat.
+- Pass ``clear_chat_id=True`` to drop the current link (the SDK sends
+  ``chatId=None`` on the wire; the server then spawns a fresh chat on every
+  trigger).
+- Omit both to leave the current chat setting untouched.
+
+Mixing them raises :class:`TypeError` before the SDK call.
+
+.. warning::
+
+    **Experimental.** Lives under :mod:`unique_toolkit.experimental`. The API
+    may change without notice.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import unique_sdk
+
+from unique_toolkit.experimental.scheduled_task.schemas import (
+    DeletedScheduledTask,
+    ScheduledTask,
+)
+
+
+def create_scheduled_task(
+    user_id: str,
+    company_id: str,
+    *,
+    cron_expression: str,
+    assistant_id: str,
+    prompt: str,
+    enabled: bool = True,
+    chat_id: str | None = None,
+) -> ScheduledTask:
+    """Create a new cron-based scheduled task.
+
+    Args:
+        user_id: Acting user (SDK requirement).
+        company_id: Owning company (SDK requirement).
+        cron_expression: 5-field UTC cron expression (``"m h dom mon dow"``).
+        assistant_id: Assistant id to execute on every trigger.
+        prompt: Prompt text sent to the assistant on each run.
+        enabled: Whether the task is active from creation. Defaults to
+            ``True`` so tasks fire as soon as they are registered; pass
+            ``False`` to stage a task that can be enabled later via
+            :func:`update_scheduled_task`.
+        chat_id: Optional chat to continue; ``None`` (default) means a fresh
+            chat is created every run.
+
+    Returns:
+        The created :class:`ScheduledTask` as echoed by the server.
+    """
+    params: dict[str, Any] = {
+        "cronExpression": cron_expression,
+        "assistantId": assistant_id,
+        "prompt": prompt,
+        "enabled": enabled,
+    }
+    if chat_id is not None:
+        params["chatId"] = chat_id
+
+    payload = unique_sdk.ScheduledTask.create(
+        user_id=user_id,
+        company_id=company_id,
+        **params,
+    )
+    return ScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+async def create_scheduled_task_async(
+    user_id: str,
+    company_id: str,
+    *,
+    cron_expression: str,
+    assistant_id: str,
+    prompt: str,
+    enabled: bool = True,
+    chat_id: str | None = None,
+) -> ScheduledTask:
+    """Async :func:`create_scheduled_task`."""
+    params: dict[str, Any] = {
+        "cronExpression": cron_expression,
+        "assistantId": assistant_id,
+        "prompt": prompt,
+        "enabled": enabled,
+    }
+    if chat_id is not None:
+        params["chatId"] = chat_id
+
+    payload = await unique_sdk.ScheduledTask.create_async(
+        user_id=user_id,
+        company_id=company_id,
+        **params,
+    )
+    return ScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+def list_scheduled_tasks(user_id: str, company_id: str) -> list[ScheduledTask]:
+    """List every scheduled task visible to the acting user."""
+    result = unique_sdk.ScheduledTask.list(user_id=user_id, company_id=company_id)
+    return [
+        ScheduledTask.model_validate(task, by_alias=True, by_name=True)
+        for task in result
+    ]
+
+
+async def list_scheduled_tasks_async(
+    user_id: str, company_id: str
+) -> list[ScheduledTask]:
+    """Async :func:`list_scheduled_tasks`."""
+    result = await unique_sdk.ScheduledTask.list_async(
+        user_id=user_id, company_id=company_id
+    )
+    return [
+        ScheduledTask.model_validate(task, by_alias=True, by_name=True)
+        for task in result
+    ]
+
+
+def get_scheduled_task(
+    user_id: str,
+    company_id: str,
+    *,
+    task_id: str,
+) -> ScheduledTask:
+    """Fetch the full detail of a single scheduled task by id."""
+    payload = unique_sdk.ScheduledTask.retrieve(
+        user_id=user_id,
+        company_id=company_id,
+        id=task_id,
+    )
+    return ScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+async def get_scheduled_task_async(
+    user_id: str,
+    company_id: str,
+    *,
+    task_id: str,
+) -> ScheduledTask:
+    """Async :func:`get_scheduled_task`."""
+    payload = await unique_sdk.ScheduledTask.retrieve_async(
+        user_id=user_id,
+        company_id=company_id,
+        id=task_id,
+    )
+    return ScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+def update_scheduled_task(
+    user_id: str,
+    company_id: str,
+    *,
+    task_id: str,
+    cron_expression: str | None = None,
+    assistant_id: str | None = None,
+    prompt: str | None = None,
+    chat_id: str | None = None,
+    clear_chat_id: bool = False,
+    enabled: bool | None = None,
+) -> ScheduledTask:
+    """Update an existing scheduled task (server-side partial update).
+
+    Only the keyword arguments you pass are sent to the API; everything else is
+    left untouched. Pass ``clear_chat_id=True`` to remove the current chat link
+    (``chatId=None`` on the wire) — the server will then spin up a brand-new
+    chat on every future trigger.
+
+    Raises:
+        TypeError: If ``chat_id`` and ``clear_chat_id=True`` are combined.
+    """
+    params = _build_update_params(
+        cron_expression=cron_expression,
+        assistant_id=assistant_id,
+        prompt=prompt,
+        chat_id=chat_id,
+        clear_chat_id=clear_chat_id,
+        enabled=enabled,
+    )
+    payload = unique_sdk.ScheduledTask.modify(
+        user_id=user_id,
+        company_id=company_id,
+        id=task_id,
+        **params,
+    )
+    return ScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+async def update_scheduled_task_async(
+    user_id: str,
+    company_id: str,
+    *,
+    task_id: str,
+    cron_expression: str | None = None,
+    assistant_id: str | None = None,
+    prompt: str | None = None,
+    chat_id: str | None = None,
+    clear_chat_id: bool = False,
+    enabled: bool | None = None,
+) -> ScheduledTask:
+    """Async :func:`update_scheduled_task`."""
+    params = _build_update_params(
+        cron_expression=cron_expression,
+        assistant_id=assistant_id,
+        prompt=prompt,
+        chat_id=chat_id,
+        clear_chat_id=clear_chat_id,
+        enabled=enabled,
+    )
+    payload = await unique_sdk.ScheduledTask.modify_async(
+        user_id=user_id,
+        company_id=company_id,
+        id=task_id,
+        **params,
+    )
+    return ScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+def delete_scheduled_task(
+    user_id: str,
+    company_id: str,
+    *,
+    task_id: str,
+) -> DeletedScheduledTask:
+    """Permanently delete a scheduled task. This action cannot be undone."""
+    payload = unique_sdk.ScheduledTask.delete(
+        user_id=user_id,
+        company_id=company_id,
+        id=task_id,
+    )
+    return DeletedScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+async def delete_scheduled_task_async(
+    user_id: str,
+    company_id: str,
+    *,
+    task_id: str,
+) -> DeletedScheduledTask:
+    """Async :func:`delete_scheduled_task`.
+
+    Falls back to :func:`asyncio.to_thread` if the SDK method does not provide
+    an ``_async`` variant, so the event loop is never blocked.
+    """
+    sdk_async = getattr(unique_sdk.ScheduledTask, "delete_async", None)
+    if sdk_async is None:
+        return await asyncio.to_thread(
+            delete_scheduled_task,
+            user_id,
+            company_id,
+            task_id=task_id,
+        )
+    payload = await sdk_async(
+        user_id=user_id,
+        company_id=company_id,
+        id=task_id,
+    )
+    return DeletedScheduledTask.model_validate(payload, by_alias=True, by_name=True)
+
+
+def _build_update_params(
+    *,
+    cron_expression: str | None,
+    assistant_id: str | None,
+    prompt: str | None,
+    chat_id: str | None,
+    clear_chat_id: bool,
+    enabled: bool | None,
+) -> dict[str, Any]:
+    """Translate toolkit kwargs into the SDK ``ScheduledTask.ModifyParams`` shape.
+
+    Fields that were not provided are omitted entirely (partial update). The
+    ``chat_id`` / ``clear_chat_id`` pair is mutually exclusive; passing both is
+    a usage error and raises :class:`TypeError` here — never at the SDK layer.
+    """
+    if chat_id is not None and clear_chat_id:
+        raise TypeError(
+            "update_scheduled_task: pass either chat_id= to set a new chat or "
+            "clear_chat_id=True to clear it, not both."
+        )
+
+    params: dict[str, Any] = {}
+    if cron_expression is not None:
+        params["cronExpression"] = cron_expression
+    if assistant_id is not None:
+        params["assistantId"] = assistant_id
+    if prompt is not None:
+        params["prompt"] = prompt
+    if chat_id is not None:
+        params["chatId"] = chat_id
+    elif clear_chat_id:
+        params["chatId"] = None
+    if enabled is not None:
+        params["enabled"] = enabled
+    return params