unique-sdk 2026.32.0.dev13__tar.gz → 2026.32.0.dev14__tar.gz

{unique_sdk-2026.32.0.dev13 → unique_sdk-2026.32.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-sdk
-Version: 2026.32.0.dev13
+Version: 2026.32.0.dev14
 Summary: 
 Author: Martin Fadler, Konstantin Krauss, Andreas Hauri
 Author-email: Martin Fadler <martin.fadler@unique.ch>, Konstantin Krauss <konstantin@unique.ch>, Andreas Hauri <andreas@unique.ch>

{unique_sdk-2026.32.0.dev13 → unique_sdk-2026.32.0.dev14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_sdk"
-version = "2026.32.0.dev13"
+version = "2026.32.0.dev14"
 description = ""
 readme = "README.md"
 license = { text = "MIT" }

{unique_sdk-2026.32.0.dev13 → unique_sdk-2026.32.0.dev14}/unique_sdk/api_resources/_agentic_table.py

@@ -600,6 +600,38 @@ class AgenticTable(APIResource["AgenticTable"]):
             ),
         )
 
+    @classmethod
+    async def rerun_row(
+        cls,
+        user_id: str,
+        company_id: str,
+        tableId: str,
+        rowOrder: int,
+    ) -> MagicTableActionResult:
+        """Re-run the agent for a single row (`POST /magic-table/{tableId}/row/{rowOrder}/rerun`).
+
+        The only way to re-answer part of a sheet: importing questions is
+        delta-based, so it will not re-answer a row that already exists.
+
+        Asynchronous, like the whole-sheet run — the sheet enters ``PROCESSING``
+        and this returns once the trigger is accepted.
+
+        ``rowOrder`` is the sheet's own row numbering, the same one ``get_cell``
+        takes: row 0 is the header, so answerable rows start at 1 and row 0 is
+        rejected by the API.
+        """
+        url = f"/magic-table/{tableId}/row/{rowOrder}/rerun"
+        return cast(
+            MagicTableActionResult,
+            await cls._static_request_async(
+                "post",
+                url,
+                user_id,
+                company_id,
+                {},
+            ),
+        )
+
     @classmethod
     async def list_artifacts(
         cls,

{unique_sdk-2026.32.0.dev13 → unique_sdk-2026.32.0.dev14}/unique_sdk/cli/cli.py

@@ -22,6 +22,7 @@ from unique_sdk.cli.commands.agentic_table_write import (
     cmd_create_sheet,
     cmd_export,
     cmd_import,
+    cmd_rerun_row,
 )
 from unique_sdk.cli.commands.browser import (
     cmd_browser_action,
@@ -2212,8 +2213,9 @@ Work with Agentic Table (magic table) sheets over the public magic-table API.
 
 \b
 Reads (get-sheet / get-cell / cell-history / list-exports) are Tier 0: no
-confirmation, no side effects. Writes (create-sheet / import / export) build
-and run a sheet — the full loop of create, populate, run, and export. Every
+confirmation, no side effects. Writes (create-sheet / import / rerun-row /
+export) build and run a sheet — the full loop of create, populate, run, and
+export, plus re-answering a single row. Every
 call is scoped to the current user/company; sheet-role access (Owner / Can
 manage / Can edit) is enforced server-side and a denial is reported as
 `agentic-table: permission denied`.
@@ -2229,6 +2231,7 @@ Read subcommands:
 Write subcommands:
   create-sheet   Create a new sheet in a space
   import         Import questions/sources (adding questions triggers the run)
+  rerun-row      Re-run the agent for a single row (import cannot redo a row)
   export         Generate export artifacts (report / question export)
 
 \b
@@ -2544,6 +2547,79 @@ def agentic_table_import(
     )
 
 
+@agentic_table.command(name="rerun-row")
+@click.argument("table_id")
+# Rejected locally rather than by the endpoint: a rerun is an audited write, so
+# a row number that cannot refer to an answerable row would otherwise cost a
+# round trip and leave an audit entry for input the client could see was wrong.
+@click.argument("row_order", type=click.IntRange(min=1))
+@click.option(
+    "--wait",
+    "wait",
+    is_flag=True,
+    default=False,
+    help="Wait for the triggered rerun to finish before returning.",
+)
+@click.option(
+    "--timeout",
+    "timeout",
+    type=click.FloatRange(min=0),
+    default=600.0,
+    show_default=True,
+    help="Max seconds to wait when --wait is set.",
+)
+@click.option(
+    "--start-timeout",
+    "start_timeout",
+    type=click.FloatRange(min=0),
+    default=120.0,
+    show_default=True,
+    help=(
+        "Max seconds to wait for the rerun to be picked up before treating it "
+        "as never started. Raise it when the worker queue is slow."
+    ),
+)
+@click.option(
+    "--json", "output_json", is_flag=True, default=False, help="Print raw JSON."
+)
+@click.pass_context
+def agentic_table_rerun_row(
+    ctx: click.Context,
+    table_id: str,
+    row_order: int,
+    wait: bool,
+    timeout: float,
+    start_timeout: float,
+    output_json: bool,
+) -> None:
+    """Re-run the agent for a single row.
+
+    \b
+    Use this to redo one answer: import is delta-based and skips questions the
+    sheet already has, so it cannot re-answer an existing row. ROW_ORDER is the
+    same number get-cell --row takes: row 0 is the header, so answerable rows
+    start at 1. A locked or final row is rejected; so is a rerun while the sheet
+    is already processing, which clears once the current run finishes.
+
+    \b
+    Examples:
+      unique-cli agentic-table rerun-row mt_abc123 4
+      unique-cli agentic-table rerun-row mt_abc123 4 --wait
+    """
+    emit(
+        cmd_rerun_row(
+            LazyState.get(ctx),
+            table_id,
+            row_order,
+            wait=wait,
+            timeout=timeout,
+            start_timeout=start_timeout,
+            output_json=output_json,
+        ),
+        is_error=_is_agentic_table_error_output,
+    )
+
+
 @agentic_table.command(name="export")
 @click.argument("table_id")
 @click.option(

{unique_sdk-2026.32.0.dev13 → unique_sdk-2026.32.0.dev14}/unique_sdk/cli/commands/agentic_table_write.py

@@ -4,6 +4,7 @@ The full-loop write slice over the public magic-table API (``2023-12-06``):
 
 - ``create-sheet`` — create an empty sheet in a space.
 - ``import`` — add questions/sources; adding new questions triggers the agent run.
+- ``rerun-row`` — re-run the agent for a single row.
 - ``export`` — generate export artifacts (report / question export) and list them.
 
 Together these let an agent build a sheet, run it, and collect the answers it
@@ -288,6 +289,88 @@ def cmd_import(
         return _error(exc)
 
 
+def cmd_rerun_row(
+    state: ShellState,
+    table_id: str,
+    row_order: int,
+    *,
+    wait: bool = False,
+    timeout: float = _DEFAULT_WAIT_TIMEOUT_SECONDS,
+    start_timeout: float = _RUN_START_TIMEOUT_SECONDS,
+    output_json: bool = False,
+) -> str:
+    """Re-run the agent for one row (``POST .../row/{rowOrder}/rerun``).
+
+    The only way to re-answer part of a sheet: ``import`` is delta-based and
+    skips questions the sheet already has, so it cannot redo an existing row.
+
+    ``row_order`` is the same number ``get-cell --row`` takes — row 0 is the
+    header, so answerable rows start at 1 — and the CLI rejects anything below
+    that before the request is made. The backend declines a row that is locked
+    or in a final review status, and any rerun while the sheet is already
+    ``PROCESSING``.
+
+    Unlike ``import``, a rerun always triggers a run, so there is no benign
+    "nothing started" case: with ``wait``, not observing one is an error.
+
+    The wait watches *sheet* state, which on a shared sheet cannot be attributed
+    to this row's rerun specifically: a run someone else started looks the same.
+    A row-level signal would fix that (UN-23683).
+    """
+
+    async def _run() -> str:
+        result = await AgenticTable.rerun_row(
+            user_id=state.config.user_id,
+            company_id=state.config.company_id,
+            tableId=table_id,
+            rowOrder=row_order,
+        )
+        if not result.get("status"):
+            return _rejected(result, action="rerun")
+        if output_json and not wait:
+            return json.dumps({"result": result}, indent=2, default=str)
+        if not wait:
+            return format_agentic_table_action_result(result, action="rerun")
+
+        started, final_state, timed_out = await _wait_for_run(
+            state, table_id, timeout=timeout, start_timeout=start_timeout
+        )
+        if timed_out:
+            return (
+                f"{AGENTIC_TABLE_ERROR_PREFIX} timed out after {timeout:g}s waiting "
+                f"for the row {row_order} rerun to finish (sheet {table_id} still "
+                "PROCESSING)"
+            )
+        if not started:
+            window = min(start_timeout, timeout)
+            return (
+                f"{AGENTIC_TABLE_ERROR_PREFIX} rerun of row {row_order} on sheet "
+                f"{table_id} was accepted but no run was observed within "
+                f"{window:g}s (state: {final_state}); it may have finished between "
+                "polls or may still be waiting to be picked up, so read the row "
+                "back with cell-history to see whether it was re-answered"
+            )
+        if output_json:
+            return json.dumps(
+                {
+                    "result": result,
+                    "rowOrder": row_order,
+                    "finalState": str(final_state) if final_state else None,
+                },
+                indent=2,
+                default=str,
+            )
+        return (
+            f"{format_agentic_table_action_result(result, action='rerun')}\n"
+            f"Row {row_order} rerun finished (state: {final_state})."
+        )
+
+    try:
+        return asyncio.run(_run())
+    except UniqueError as exc:
+        return _error(exc)
+
+
 def cmd_export(
     state: ShellState,
     table_id: str,

{unique_sdk-2026.32.0.dev13 → unique_sdk-2026.32.0.dev14}/unique_sdk/cli/skills/unique-cli-agentic-table/SKILL.md

@@ -21,11 +21,17 @@ Commands fall into two groups:
 
 - **Read (Tier 0)** — `get-sheet`, `get-cell`, `cell-history`, `list-exports`.
   Never modify anything, never need confirmation.
-- **Write (Tier 1)** — `create-sheet`, `import`, `export`. These create a sheet,
-  add questions and sources, start the agent run, and produce export artifacts.
-  They add to a sheet rather than overwriting existing answers, so they do not
-  prompt for confirmation — but they do change a shared artifact, so say what
-  you did afterwards. Nothing here deletes or replaces a human's answer.
+- **Write (Tier 1)** — `create-sheet`, `import`, `export`, `rerun-row`. These
+  create a sheet, add questions and sources, start the agent run, produce
+  export artifacts, and redo a single answer. None of them prompts for
+  confirmation, but they do change a shared artifact, so say what you did
+  afterwards.
+
+  The first three only add. `rerun-row` is the exception: it replaces the
+  answer in the row you name. The previous answer stays in `cell-history` and
+  a settled row is refused outright, so the change is recoverable and the
+  approved rows are protected — but name the row you are redoing when you
+  report back, and check you have the right one first.
 
 ## Permissions
 
@@ -156,6 +162,42 @@ returns the same error.
 unique-cli agentic-table import mt_abc123 --question-file-id c_q --source-file-id c_src --wait
 ```
 
+### Re-answer a single row
+
+```bash
+unique-cli agentic-table rerun-row <table_id> <row_order> [--wait] [--timeout <seconds>] [--start-timeout <seconds>]
+```
+
+Use this to redo one answer. **Re-importing a question will not redo it** —
+import is delta-based and skips questions the sheet already has, so `rerun-row`
+is the only way to re-answer an existing row.
+
+`<row_order>` uses **the same numbering as `--row` on `get-cell`**: row 0 is the
+header, data rows start at 1. So the row you inspected with
+`get-cell --row 4` is the row you redo with `rerun-row <table_id> 4` — no
+offset. Row 0 is rejected, since there is nothing to answer in a header.
+
+Two kinds of refusal, which need different responses:
+
+- **The row is not yours to redo.** A locked row, or one in a final review
+  status, is declined because a person has settled that answer. Report it; do
+  not look for a way around it.
+- **Not now.** A rerun while the sheet is already processing is declined
+  because only one run may be in flight. That clears by itself — wait for the
+  current run to finish and try again.
+
+A rerun always starts a run, so with `--wait` there is no benign "nothing
+started" case: if no run appears within 120s the command fails.
+
+```bash
+unique-cli agentic-table rerun-row mt_abc123 4 --wait
+```
+
+To redo several rows, do them one at a time with `--wait`: the sheet takes one
+run at a time, so a second `rerun-row` fired before the first finishes is
+declined. There is no batch form. If most of the sheet needs redoing, consider
+a fresh sheet instead.
+
 ### Export answers
 
 ```bash
@@ -195,9 +237,16 @@ answered, skip the create and import steps: read the answers with
 `get-sheet --cells` or `get-cell`, and use `cell-history` if you need to know
 whether an answer came from a person or the assistant.
 
+If a specific answer looks wrong or incomplete, fix that row with `rerun-row`
+and export again, rather than re-importing the question or rebuilding the
+sheet.
+
 ## Rules
 
-1. `--row` and `--col` are **0-based** orders. Row 0 is the header row.
+1. Rows and columns are numbered from 0, and row 0 is the header — so the first
+   question is row 1. This holds for `--row`/`--col` on `get-cell` and
+   `cell-history` and for `<row_order>` on `rerun-row` alike; the same number
+   means the same row in every command.
 2. Fetch what you need, not everything. `get-cell` for one value,
    `get-sheet --cells` for an overview — don't dump a whole sheet unless asked.
 3. Use `--wait` when a later step depends on the result, and only then. Without