@evolvingmachines/evolve 0.0.65 → 0.0.66

package/skills/evolve-evals/references/sdk-reference/meta.mdx

@@ -1,52 +0,0 @@
----
-title: "meta"
-description: "The platform's capability document, no key needed."
----
-
-`meta()` fetches the capability document, `GET /api/meta`: everything a client would otherwise hardcode. It needs no API key.
-
-- `agents`: every built-in, with `runnable` and `reason`, `default_model` and `models` (the picker's list; a job still requires an explicit model), `effort_support` (`level`, `binary` or `none`) and `default_effort`, `version_pinnable` and `latest_version` (null means not known right now), `supports_config` and `presets`.
-- `agent_registration`: the rules a registration must satisfy: `name_pattern`, the length and size caps, `max_per_user`, `reserved_names`, `reserved_env_keys`.
-- `sandbox_providers`: each provider's `sizing` ceilings, its `gpus` block, and its `refuses` list; `platform_constraints` beside it holds what no provider runs. `gpu_concurrency_cap` is the fleet's cap on GPU trials in flight.
-- `managed_providers`: the managed sandbox doors this deployment serves, a managed-agents fact.
-- `network_modes`: the three modes a task may declare.
-- `statuses`: the `job`, `trial`, `import` and `dataset_version` vocabularies, each with its `terminal` members.
-- `analyze`: the analyzer's `default_model`, its `reasoning_efforts`, and each roster model's `default_reasoning_effort`.
-- `limits`: `job` (`n_concurrent_trials` default and max, `default_max_trial_spend_usd`, `default_max_retries`, `default_sandbox_provider`, `default_sizing`, `model_required`, `default_agent_timeout_sec`, `default_verifier_timeout_sec`, `default_timeout_multiplier`, the effort vocabulary), `compare` (`min_ids`, `max_ids`), `pagination` (a default and max per collection kind), `uploads` (the one physical ceiling per archive kind with `archive_bytes_source`, the agent tarball and skill caps), `dataset_names`, and `max_items_named_in_error_message`, which is why `details` exists.
-- `error_codes` and `import_warning_codes`: the closed lists.
-
-`schema_version` moves when a field changes meaning, never when a value changes. The response carries an `ETag` and `Cache-Control: public, max-age=300, stale-while-revalidate=300`; send the ETag back as `If-None-Match` and an unchanged document answers 304.
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    import { meta } from "@evolvingmachines/evolve";
-
-    function meta(config?: HostedClientConfig): Promise<CapabilityDocument>
-    ```
-
-    Also `hosted().meta()`.
-
-    ```ts
-    const doc = await meta();
-    for (const agent of doc.agents) console.log(agent.name, agent.models.map((m) => m.alias));
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    from evolve import meta
-
-    async def meta(config: Optional[HostedClientConfig] = None) -> CapabilityDocument
-    ```
-
-    Also `await hosted().meta()`.
-
-    ```python
-    doc = await meta()
-    for agent in doc.agents: print(
-        agent.name,
-        [m.alias for m in agent.models],
-    )
-    ```
-  </Tab>
-</Tabs>

package/skills/evolve-evals/references/sdk-reference/skills.mdx

@@ -1,69 +0,0 @@
----
-title: "skills"
-description: "Upload and manage platform-stored skills."
----
-
-`skills()` returns the skills client. An uploaded skill is referenced from a job as `upload:<id>` or `name:<skill-name>`.
-
-## upload
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    upload(directory: string, options?: { org?: string }): Promise<SkillUpload[]>
-    ```
-
-    Upload a skill folder. Its name becomes your moving name pointer. The record belongs to you and to an organization (`org`, a slug or id; omitted, the client's `org` default, else your personal one): its members may reference it from their own jobs, and only you can delete it.
-
-    ```ts
-    const [skill] = await skills().upload("./my-skill", { org: "acme" });
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def upload(directory: str, *, org: Optional[str] = None) -> List[SkillUpload]
-    ```
-
-    Upload a skill folder. Its name becomes your moving name pointer. The record belongs to you and to an organization (`org`, a slug or id; omitted, the client's `org` default, else your personal one): its members may reference it from their own jobs, and only you can delete it.
-
-    ```python
-    [skill] = await skills().upload("./my-skill", org="acme")
-    ```
-  </Tab>
-</Tabs>
-
-## list, get, delete
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    list(options?: { scope?: "my" | "shared" | "org"; limit?: number; cursor?: string }): SkillUploadList
-    get(id: string): Promise<SkillUpload & { skill_md: string | null }>
-    delete(id: string): Promise<void>
-    ```
-
-    Uploads, one upload with its `SKILL.md`, or delete one. `scope` is the lists' own vocabulary: `"my"` (yours, the default), `"shared"` (your organizations' other members') or `"org"` (everything in your organizations, yours included). A skill a running job references cannot be deleted, and deleting stays with the owner.
-
-    ```ts
-    const one = await skills().get(skill.id);
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    def list(
-        *,
-        scope: Optional[Literal['my', 'shared', 'org']] = None,
-        limit: Optional[int] = None,
-        cursor: Optional[str] = None,
-    )
-    async def get(skill_id: str) -> SkillUpload
-    async def delete(skill_id: str) -> None
-    ```
-
-    Your uploads, one upload, or delete one. A skill a running job references cannot be deleted.
-
-    ```python
-    one = await skills().get(skill.id)
-    ```
-  </Tab>
-</Tabs>

package/skills/evolve-evals/references/sdk-reference/trials.mdx

@@ -1,302 +0,0 @@
----
-title: "trials"
-description: "Read, download, and act on single trials."
----
-
-`trials()` returns the trials client. A trial id is global: no method needs the job id.
-
-## get
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    get(trialId: string): Promise<Trial>
-    ```
-
-    One trial in full. Its `job_id` points back to the job.
-
-    ```ts
-    const trial = await trials().get("d1a10c4e-…");
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def get(trial_id: str) -> Trial
-    ```
-
-    One trial in full. Its `job_id` points back to the job.
-
-    ```python
-    trial = await trials().get("d1a10c4e-…")
-    ```
-  </Tab>
-</Tabs>
-
-## trace, traceEvents
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    trace(
-      trialId: string,
-      options?: { cursor?: string; limit?: number; type?: string; grep?: string; tail?: number },
-    ): Promise<TraceEventPage>
-    traceEvents(
-      trialId: string,
-      options?: TraceOptions,
-    ): AsyncIterableIterator<TraceEvent>
-    ```
-
-    One page of the parsed trace, or every available event; `traceEvents` drains what is stored and stops. `type` (an exact type), `grep` (a case-insensitive regex over type and content, a plain string being a substring) and `tail` (the last N matches, 1 to 10000) filter on the server and compose with the cursor.
-
-    A cursor is a `seq`: to resume later, pass the last event's `seq` as a string. `limit` defaults to 200, at most 1000, and event 0 is the instruction.
-
-    ```ts
-    for await (const event of trials().traceEvents(
-      trial.id,
-      { grep: "permission denied" },
-    )) {
-      console.log(event.seq, event.type);
-    }
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def trace(
-        trial_id: str,
-        *,
-        cursor=None,
-        limit=None,
-        type=None,
-        grep=None,
-        tail=None,
-    ) -> TraceEventPage
-    async def trace_events(
-        trial_id: str,
-        *,
-        cursor=None,
-        limit=None,
-        type=None,
-        grep=None,
-        tail=None,
-    )
-    ```
-
-    One page of the parsed trace, or every available event; `trace_events` drains what is stored and stops. `type` (an exact type), `grep` (a case-insensitive regex over type and content, a plain string being a substring) and `tail` (the last N matches, 1 to 10000) filter on the server and compose with the cursor.
-
-    A cursor is a `seq`: to resume later, pass the last event's `seq` as a string. `limit` defaults to 200, at most 1000, and event 0 is the instruction.
-
-    ```python
-    async for event in trials().trace_events(
-        trial.id,
-        grep="permission denied",
-    ):
-        print(event.seq, event.type)
-    ```
-  </Tab>
-</Tabs>
-
-## artifact
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    artifact(
-      trialId: string,
-      stream: "verifier" | "trace-stdout" | "trace-stderr" | "trace-atif" | "trajectory",
-    ): Promise<string | null>
-    artifact(
-      trialId: string,
-      stream: "agent-home",
-    ): Promise<Record<string, string> | null>
-    ```
-
-    One raw artifact, the same names `evolve trial download --stream` takes. Null means the trial never stored it.
-
-    ```ts
-    const log = await trials().artifact(trial.id, "verifier");
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def artifact(
-        trial_id: str,
-        stream: Literal['trace-parsed', 'verifier', 'trace-stdout', 'trace-stderr', 'trace-atif', 'trajectory', 'agent-home'],
-    ) -> Optional[Union[str, Dict[str, str]]]
-    ```
-
-    One raw artifact, the same names `evolve trial download --stream` takes. None means the trial never stored it. `trace-parsed` is refused here; use `trace()`.
-
-    ```python
-    log = await trials().artifact(trial.id, "verifier")
-    ```
-  </Tab>
-</Tabs>
-
-## files, file
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    files(
-      trialId: string,
-      options?: { limit?: number; cursor?: string },
-    ): Promise<TrialFilePage>
-    file(
-      trialId: string,
-      path: string,
-      range?: { start?: number; end?: number; suffix?: number },
-    ): Promise<Buffer>
-    ```
-
-    Every file the platform stored for the trial, as `{ path, size_bytes }` rows sorted by path (`limit` default 200, at most 1000), and the raw bytes of one of them. A range reads a slice; `suffix` reads the last N bytes. A very large file must be read by range. There is no CLI verb for either.
-
-    ```ts
-    const tail = await trials().file(
-      trial.id,
-      "verifier/test-stdout.txt",
-      { suffix: 4096 },
-    );
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def files(
-        trial_id: str,
-        *,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
-    ) -> TrialFilePage
-    async def file(
-        trial_id: str,
-        path: str,
-        *,
-        start: Optional[int] = None,
-        end: Optional[int] = None,
-        suffix: Optional[int] = None,
-    ) -> bytes
-    ```
-
-    Every file the platform stored for the trial, as `path` and `size_bytes` rows sorted by path (`limit` default 200, at most 1000), and the raw bytes of one of them. A range reads a slice; `suffix` reads the last N bytes. A very large file must be read by range. There is no CLI verb for either.
-
-    ```python
-    tail = await trials().file(
-        trial.id,
-        "verifier/test-stdout.txt",
-        suffix=4096,
-    )
-    ```
-  </Tab>
-</Tabs>
-
-## regrade, retry, stop
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    regrade(trialId: string): Promise<Job>
-    retry(
-      trialId: string,
-      options?: StartJobOptions,
-    ): Promise<Job>
-    stop(trialIds: string[]): Promise<StopResponse>
-    ```
-
-    Re-run only the verifier, run the trial again, or stop in-flight trials. A regrade and a retry each return a new one-trial job; `regrade` is refused with `regrade_source_ineligible` for a shared-mode trial, `retry` with `trial_not_settled` for a live one.
-
-    `stop` takes at most 100 ids, trials and analyses mixed, and reports each in exactly one of `stopped`, `stopped_analyses`, `already_terminal` or `not_found`. Stopped trials rejoin the run on a `resume` of their job.
-
-    ```ts
-    const again = await trials().retry(trial.id);
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    async def regrade(trial_id: str) -> Job
-    async def retry(
-        trial_id: str,
-        *,
-        idempotency_key: Optional[str] = None,
-    ) -> Job
-    async def stop(trial_ids: List[str]) -> StopResponse
-    ```
-
-    Re-run only the verifier, run the trial again, or stop in-flight trials. A regrade and a retry each return a new one-trial job; `regrade` is refused with `regrade_source_ineligible` for a shared-mode trial, `retry` with `trial_not_settled` for a live one.
-
-    `stop` takes at most 100 ids, trials and analyses mixed, and reports each in exactly one of `stopped`, `stopped_analyses`, `already_terminal` or `not_found`. Stopped trials rejoin the run on a `resume` of their job.
-
-    ```python
-    again = await trials().retry(trial.id)
-    ```
-  </Tab>
-</Tabs>
-
-## filesystem(trialId: string)
-
-<Tabs>
-  <Tab title="TypeScript">
-    ```ts
-    filesystem(trialId: string): RunFilesystem
-
-    interface RunFilesystem {
-      status(): Promise<FilesystemStatus>
-      list(options?: { path?: string; source?: "live" | "capture"; cursor?: string; limit?: number }): Promise<FilesystemListing>
-      read(path: string, options?: { source?: "live" | "capture"; range?: TrialFileRange }): Promise<Buffer>
-      search(options: { q: string; path?: string; regex?: boolean; limit?: number; source?: "live" | "capture" }): Promise<FilesystemSearchResult>
-      changes(options?: { source?: "live" | "capture"; phase?: "setup" | "agent" | "verifier" | "all"; cursor?: string; limit?: number }): Promise<FilesystemChanges>
-      archive(options?: { path?: string; source?: "live" | "capture" }): Promise<Buffer>
-      archive(options: { path?: string; source?: "live" | "capture"; to: string }): Promise<string>
-      watch(paths: string[]): Promise<FilesystemWatchResult>
-      events(options?: { lastEventId?: string; signal?: AbortSignal }): AsyncIterableIterator<FilesystemStreamEvent>
-      logs(options: { stream: SandboxLogStream; cursor?: string; limit?: number }): Promise<SandboxLogLines>
-      logEvents(options?: { lastEventId?: string; signal?: AbortSignal }): AsyncIterableIterator<SandboxLogEvent>
-      procs(): Promise<SandboxProcs>
-    }
-    ```
-
-    The trial's file system, sandbox logs and process list. While the box runs, every read sees it as it changes; after the run, the same reads answer from the kept tree. `status()` says which (`state`: `live`, `captured`, `capturing`, `none`), and `source` on a read forces one — a source that is not there is refused with `filesystem_state`.
-
-    `list` pages one folder by name; each entry says whether the run created or modified it and in which phase, and on the kept tree `captured: false` marks a file the run never touched (it lists but does not open — `not_captured`). `read` answers raw bytes, a slice with `range`. `search` finds text under a folder, or over the whole box when `path` is `/` (seconds); `truncated` says there was more. `changes` is the flat list of what the run created, modified or removed. `archive` is a `.tar.gz` of one subtree, in memory or saved under `to`; while the box runs, a subtree too large to read out in time is refused (`feature_unsupported`).
-
-    `events` yields change frames while the box lives (`state`, then one `fs` per change with its `seq`, `path` and `type`); on a provider without a native watcher, `watch(paths)` declares the folders you have open so their changes are reported (at most 8). `logs` pages one stream — `agent`, `verifier`, or `system` when the job asked for it; `setup` and `metrics` are named but not recorded today, so their page is empty with a `reason` — and `logEvents` follows every stream while the box lives. `procs` is the live process list.
-
-    ```ts
-    const fs = trials().filesystem(trial.id);
-    const { state } = await fs.status();
-    for (const entry of (await fs.list({ path: "/app/work" })).entries) console.log(entry.name, entry.changed);
-    const main = (await fs.read("/app/work/main.py")).toString("utf8");
-    for await (const frame of fs.events()) if (frame.event === "fs") console.log(frame.data.path, frame.data.type);
-    ```
-  </Tab>
-  <Tab title="Python">
-    ```python
-    def filesystem(self, trial_id: str) -> RunFilesystem
-
-    class RunFilesystem:
-        async def status(self) -> FilesystemStatus
-        async def list(self, *, path="/", source=None, cursor=None, limit=None) -> FilesystemListing
-        async def read(self, path, *, source=None, start=None, end=None, suffix=None) -> bytes
-        async def search(self, q, *, path="/", regex=False, limit=None, source=None) -> FilesystemSearchResult
-        async def changes(self, *, source=None, phase=None, cursor=None, limit=None) -> FilesystemChanges
-        async def archive(self, *, path="/", source=None, to=None)  # bytes, or the saved path with to=
-        async def watch(self, paths) -> FilesystemWatchResult
-        def events(self, *, last_event_id=None) -> AsyncIterator[FilesystemStreamEvent]
-        async def logs(self, stream, *, cursor=None, limit=None) -> SandboxLogLines
-        def log_events(self, *, last_event_id=None) -> AsyncIterator[SandboxLogEvent]
-        async def procs(self) -> SandboxProcs
-    ```
-
-    The same surface, the same words: `status().state` says whether the reads answer from the running box (`live`) or the kept tree (`captured`); `source=` forces one. `read` answers bytes, a slice with `start`/`end` or `suffix`. `events` and `log_events` are async iterators over the live streams.
-
-    ```python
-    fs = trials().filesystem(trial.id)
-    print((await fs.status()).state)
-    for entry in (await fs.list(path="/app/work")).entries:
-        print(entry.name, entry.changed)
-    main = (await fs.read("/app/work/main.py")).decode()
-    async for frame in fs.events():
-        if frame.event == "fs":
-            print(frame.data["path"], frame.data["type"])
-    ```
-  </Tab>
-</Tabs>