Operations

Some work finishes in a request. Some waits: for a user to connect an account, for a person to approve, for a model to finish a turn, for a phone call to end. That kind of work returns an operation, which you can wait on now or pick up later from anywhere.

Wait for it#

import noclick

turn = agent.send("Draft the monthly report", user="user_42")
reply = turn.wait(timeout=120)

Without a timeout, wait() blocks until the operation finishes. With one, it raises noclick.OperationTimeout if the operation is still going; the operation carries on, and you can wait again.

If the operation didn't succeed, wait() raises: the operation's own error (an noclick.Error subclass), noclick.OperationCanceled, or noclick.Expired.

Come back later#

Operations live on NoClick's side, so they outlive your process. Keep the id and wait from anywhere, even a different machine:

save(turn.id)

# in a background job
reply = noclick.Operation.from_id(saved_id).wait()

The result comes back in the same type as it would have from the original call.

Check without waiting#

op = noclick.Operation.from_id(saved_id).hydrate()   # loads it now
print(op.status, op.done)

An operation's status is one of:

The first three are live; the last four are final. op.refresh() reloads an operation you already hold.

An agent's turn that's running when NoClick restarts goes back to queued and picks up where it left off on the next server, so wait() still returns its reply. The conversation gets a note saying so. A turn on a coding harness (its sandbox may already have the message) and other work NoClick restarts under fail with reason interrupted instead.

What started it#

op.input is what an operation was started with (read on one operation, not in listings). For an agent turn that a trigger started, input["conversation"] is the conversation it ran in, the key a conversation template rendered:

op = noclick.Operation.from_id(saved_id).hydrate()
print(op.input["conversation"])   # issue-1841

A turn is awaiting_human while the agent waits on a person: an answer to its ask, or a sign-in or a code its browser needs. message() keeps waiting, and returns the reply the agent writes once the person has answered.

Jobs#

A child an agent spawns works on its task as a job, a noclick.Job: an operation of kind agent.task that spans every turn the task takes. While it works its step is working, or waiting when all it has left is a wake-up it set itself; it's awaiting_human while it waits on a person. job.updates() lists what the child reported along the way. A message a coordinator sends another agent without waiting is a job too, of kind agent.message. agent.ask records each question as an agent.ask operation. noclick.Job.list(status="awaiting_human") lists the jobs across your agents, Job.summary counts them by status, and agent.jobs() reads the ones one agent started.

Follow it as it runs#

events() yields each status change until the operation finishes:

for event in op.events():
    print(event.status, event.updated_at)

See how far it got#

Long work reports as it goes, and op.progress reads it: its step, its stages (each with a name, a status of done, current or pending, and when it started_at and ended_at), the last 50 lines it printed, line_count (every line so far) and updated_at, when it last said anything.

op = project.deploy()
for stage in op.progress["stages"]:
    print(stage["name"], stage["status"])  # Queued done, Building current, Shipping pending, Live pending
print(op.progress["lines"][-1])            # the build's latest log line

It's None until the work reports something. An agent that started the operation through its NoClick tools hears each report as an operation event in its conversation's stream, so a chat can show the work live (Sharing and streaming).

Cancel it#

op.cancel()

Timing and history#

A finished operation records how long it waited to start (wait_ms), how long it ran (run_ms) and how long it was held for a person (held_ms), plus every status change in transitions. For an agent turn, op.tool_calls() lists the tools it called.

op.console_url opens the operation in the developer console, and errors raised by wait() end with the same link.

List operations#

noclick.Operation.list(status="failed", kind="agent.message", limit=20)
noclick.Operation.summary(status="live").by_status   # every status: {"queued": 0, "running": 3, ...}

See Activity for every filter.