agental 0.1.0 → 0.2.0

package/dist/client.js

@@ -1,451 +0,0 @@
-import { Http } from "./http.js";
-import { CREATE_TIMEOUT_MS, Email, iso, made, makeSandbox, Sandbox } from "./sandbox.js";
-import { Templates } from "./template.js";
-class Sandboxes {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    /**
-     * Makes a sandbox and waits until it is running. If the create fails part way or its
-     * answer is lost, it is sent again with the same key, which gives the same machine back
-     * and never a second one. What it paid in burst fees is in the sandbox's burstFeeMicros.
-     */
-    async create(options = {}) {
-        const body = {
-            name: options.name ?? made("sbx"),
-            ...(options.template ? { templateId: typeof options.template === "string" ? options.template : options.template.id } : {}),
-            ...(options.size ? { size: options.size } : {}),
-            ...(options.region === undefined ? {} : Array.isArray(options.region) ? { regions: options.region } : { region: options.region }),
-            ...(options.snapshotId !== undefined ? { snapshotId: options.snapshotId } : {}),
-            ...(options.ttlSeconds !== undefined ? { ttlSeconds: options.ttlSeconds } : {}),
-            ...(options.network ? { network: options.network } : {}),
-            ...(options.sshKeys !== undefined ? { sshKeys: options.sshKeys } : {}),
-            ...(options.tags !== undefined ? { tags: options.tags } : {}),
-            ...(options.metadata !== undefined ? { metadata: options.metadata } : {}),
-        };
-        const { info, burstFeeMicros } = await makeSandbox(this.http, "/v1/sandboxes", body, options.idempotencyKey ?? made("sdk"), options.timeoutMs ?? CREATE_TIMEOUT_MS, options);
-        return new Sandbox(this.http, info, burstFeeMicros);
-    }
-    /** One of your sandboxes, by its id. */
-    async get(id) {
-        const { body } = await this.http.json({ method: "GET", path: `/v1/sandboxes/${encodeURIComponent(id)}`, replay: true });
-        return new Sandbox(this.http, body);
-    }
-    /**
-     * Your sandboxes, stopped ones included. Given a tag, or several, only those with every
-     * one of them; given metadata, only those with each key at that value. A template's
-     * tags and metadata count.
-     */
-    async list(filter = {}) {
-        const query = {};
-        if (filter.tag !== undefined) {
-            query["tag"] = filter.tag;
-        }
-        for (const [key, value] of Object.entries(filter.metadata ?? {})) {
-            query[`metadata[${key}]`] = value;
-        }
-        const { body } = await this.http.json({ method: "GET", path: "/v1/sandboxes", query, replay: true });
-        return body.sandboxes.map((info) => new Sandbox(this.http, info));
-    }
-    /**
-     * The mail of one sandbox, by the sandbox's id, without reading the sandbox. It asks
-     * nothing by itself. It is the way in for a key made with only email.read and
-     * email.send on this sandbox, which may read and send its mail and is refused
-     * everything else, get(id) included.
-     */
-    email(id) {
-        return new Email(this.http, `/v1/sandboxes/${encodeURIComponent(id)}/email`);
-    }
-}
-class Snapshots {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    /** Every snapshot you have, those of sandboxes since deleted included. */
-    async list() {
-        return (await this.http.json({ method: "GET", path: "/v1/snapshots", replay: true })).body.snapshots;
-    }
-    async get(id) {
-        return (await this.http.json({ method: "GET", path: `/v1/snapshots/${encodeURIComponent(id)}`, replay: true })).body;
-    }
-    async delete(id) {
-        await this.http.send({ method: "DELETE", path: `/v1/snapshots/${encodeURIComponent(id)}` });
-    }
-}
-/**
- * Your API keys. A key may do what it was made to do and nothing else, and a key used to
- * make one makes only a weaker one. Using any of these takes a key with key.manage.
- */
-class ApiKeys {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    /** Every key of the account, oldest first. Their secrets are never given. */
-    async list() {
-        return (await this.http.json({ method: "GET", path: "/v1/api-keys", replay: true })).body.apiKeys;
-    }
-    async get(id) {
-        return (await this.http.json({ method: "GET", path: this.path(id), replay: true })).body;
-    }
-    /**
-     * Makes a key with a preset, or with the actions named, and limited by the rest: to some
-     * sandboxes and templates, until expiresAt, and to the addresses in allowFrom. The
-     * answer holds secret, the one time it is given. It is sent once, so a lost answer is
-     * not sent again.
-     */
-    async create(key) {
-        // What is left out is not sent: JSON has no undefined.
-        const body = { ...key, expiresAt: iso(key.expiresAt) };
-        return (await this.http.json({ method: "POST", path: "/v1/api-keys", body })).body;
-    }
-    /**
-     * Replaces the addresses and ranges a key may be used from, from its next request. It is
-     * the one thing about a key that changes after it is made. An empty list is anywhere.
-     */
-    async setAllowFrom(id, allowFrom) {
-        return (await this.http.json({ method: "PUT", path: `${this.path(id)}/allow-from`, body: { allowFrom }, replay: true })).body;
-    }
-    /** Deletes a key. Whatever holds it is refused from its next request, and the sandboxes it made stay the account's. */
-    async delete(id) {
-        await this.http.send({ method: "DELETE", path: this.path(id) });
-    }
-    /** How long the sandboxes a key made ran, and what that comes to at the list price. Without since, everything they ever ran. */
-    async usage(id, window = {}) {
-        const query = { since: iso(window.since), until: iso(window.until) };
-        return (await this.http.json({ method: "GET", path: `${this.path(id)}/usage`, query, replay: true })).body;
-    }
-    path(id) {
-        return `/v1/api-keys/${encodeURIComponent(id)}`;
-    }
-}
-/**
- * The organizations the key's person is in, and the team the key acts in. A key acts in the
- * organization it was made in, for good: its person's own or a team. What a key may do of a
- * team's is held by its actions, members.read and members.admin (or account.read and
- * account.admin), and by its person's role in the team.
- */
-class Organizations {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    /** Every organization the key's person is in, with their role in each, their own first. */
-    async list() {
-        return (await this.http.json({ method: "GET", path: "/v1/organizations", replay: true })).body.organizations;
-    }
-    /** The one the key acts in. */
-    async current() {
-        const [list, me] = await Promise.all([this.list(), this.http.json({ method: "GET", path: "/v1/me", replay: true })]);
-        const found = list.find((organization) => organization.id === me.body.activeOrganizationId);
-        if (!found) {
-            throw new Error(`The key acts in ${me.body.activeOrganizationId}, which is not among its person's organizations.`);
-        }
-        return found;
-    }
-    /**
-     * Makes a team, with the key's person as its owner. The key goes on acting where it was made:
-     * a key for the team is made in the console, or with the CLI's agental org use.
-     */
-    async createTeam(name) {
-        return (await this.http.json({ method: "POST", path: "/v1/organizations", body: { kind: "team", name } })).body.organization;
-    }
-    /** Renames a team. Only an owner does. */
-    async rename(id, name) {
-        return (await this.http.json({ method: "PATCH", path: this.path(id), body: { name }, replay: true })).body;
-    }
-    /** A team's members, the earliest first. Every member reads them. */
-    async members(id) {
-        return (await this.http.json({ method: "GET", path: `${this.path(id)}/members`, replay: true })).body.members;
-    }
-    /** Changes a member's role: an owner any, an admin up to admin and never an owner's. */
-    async setRole(id, userId, role) {
-        const path = `${this.path(id)}/members/${encodeURIComponent(userId)}`;
-        return (await this.http.json({ method: "PATCH", path, body: { role }, replay: true })).body.role;
-    }
-    /**
-     * Removes a member, or the key's person themself. The keys they made in the team go on
-     * working, as a member's, unless revokeKeys revokes them in the same request.
-     */
-    async removeMember(id, userId, options = {}) {
-        const path = `${this.path(id)}/members/${encodeURIComponent(userId)}`;
-        const query = options.revokeKeys ? { revokeKeys: "true" } : {};
-        return (await this.http.json({ method: "DELETE", path, query })).body;
-    }
-    /** The invites of the team the key acts in, for its owners and admins. */
-    async invites() {
-        return (await this.http.json({ method: "GET", path: "/v1/invites", replay: true })).body.invites;
-    }
-    /** Invites an email address to the team the key acts in, as a member or an admin. The team's plan has to allow members. */
-    async invite(email, options = {}) {
-        return (await this.http.json({ method: "POST", path: "/v1/invites", body: { email, role: options.role ?? "member" } })).body;
-    }
-    /** Revokes an open invite: its link answers 410 from then on. */
-    async revokeInvite(inviteId) {
-        await this.http.send({ method: "DELETE", path: `/v1/invites/${encodeURIComponent(inviteId)}` });
-    }
-    path(id) {
-        return `/v1/organizations/${encodeURIComponent(id)}`;
-    }
-}
-/**
- * The agental API.
- *
- * ```ts
- * const agental = new Agental(); // reads AGENTAL_API_KEY
- * const sandbox = await agental.sandboxes.create();
- * const { stdout } = await sandbox.exec("uname -a");
- * await sandbox.delete();
- * ```
- */
-export class Agental {
-    sandboxes;
-    snapshots;
-    /** What sandboxes are made as and held to: a start, the variables and files every sandbox on one gets, and what it may reach. */
-    templates;
-    /** The account's API keys: what each may do, which sandboxes and templates it reaches, until when, and from where. */
-    apiKeys;
-    /** The organizations the key's person is in, and the members and invites of a team. */
-    organizations;
-    http;
-    constructor(options = {}) {
-        this.http = new Http(options);
-        this.sandboxes = new Sandboxes(this.http);
-        this.snapshots = new Snapshots(this.http);
-        this.templates = new Templates(this.http);
-        this.apiKeys = new ApiKeys(this.http);
-        this.organizations = new Organizations(this.http);
-    }
-    /** The regions sandboxes can be made in now, the default first, with the sizes each has room for. */
-    async regions() {
-        return (await this.http.json({ method: "GET", path: "/v1/regions", replay: true })).body.regions;
-    }
-    /** Who the key belongs to: the account's id, name and address, its role, and whether it is closed. */
-    async me() {
-        return (await this.http.json({ method: "GET", path: "/v1/me", replay: true })).body;
-    }
-    /** Every port given an address, across the account's sandboxes that the key reaches. A sandbox's own are in its routes(). */
-    async hostRoutes() {
-        return (await this.http.json({ method: "GET", path: "/v1/host-routes", replay: true })).body.routes;
-    }
-    /** Hides a port's address: it answers not found from then on. There is no undoing it; give the port an address again instead. */
-    async hideHostRoute(routeId) {
-        return (await this.http.json({ method: "POST", path: `/v1/host-routes/${encodeURIComponent(routeId)}/hide`, replay: true })).body;
-    }
-    /** The sizes on offer, and how much room there is. */
-    async limits() {
-        return (await this.http.json({ method: "GET", path: "/v1/limits", replay: true })).body;
-    }
-    /** What applies to every account here: how many sandboxes, how long one runs, whether ports get public addresses. */
-    async policy() {
-        return (await this.http.json({ method: "GET", path: "/v1/policy", replay: true })).body;
-    }
-    /**
-     * What is sold: the list price an hour of each size, the monthly plans, the top-ups offered
-     * with what each adds, the range a top-up may be and its bonus, and the free month. It needs
-     * no key.
-     */
-    async prices() {
-        return (await this.http.json({ method: "GET", path: "/v1/billing/plans", replay: true })).body;
-    }
-    /**
-     * Where the account stands: its plan, in its free month or not, what it has used this month at list price,
-     * what is left of its top-ups, and whether it may run a sandbox. Amounts are millionths of a US dollar.
-     */
-    async billing() {
-        return (await this.http.json({ method: "GET", path: "/v1/billing", replay: true })).body;
-    }
-    /**
-     * Starts a purchase and gives the address of the payment page, for a person to open: a
-     * plan, or a top-up of credits that do not expire, any whole number of US dollars
-     * from 15 to 100,000. From $200 a top-up adds a bonus, 2% there and growing to 25% at
-     * $10,000: $500 adds $537. prices() says what each adds.
-     * An account that already has a plan and asks for another is moved to it at once: url is
-     * null and changed is true. Nothing is charged until the person pays.
-     */
-    async checkout(purchase) {
-        return (await this.http.json({ method: "POST", path: "/v1/billing/checkout", body: purchase })).body;
-    }
-    /**
-     * Sets the auto-reload, or turns it off with null: when the month's credits and the top-ups run
-     * out, the card saved at the last purchase is charged for a top-up of this many US dollars, with
-     * tax, and its credits are added at once, before any sandbox is stopped. At most three times a
-     * day, and not again for a day after a card that would not pay. It needs a plan or a top-up
-     * bought first, which saves the card: billing().canAutoReload says whether it can be set.
-     */
-    async setAutoReload(dollars) {
-        return (await this.http.json({ method: "PUT", path: "/v1/billing/auto-reload", body: { dollars } })).body;
-    }
-    /** The account's mail: the handle every address of its sandboxes carries, what its plan allows, and what it has had of that today. */
-    async email() {
-        return (await this.http.json({ method: "GET", path: "/v1/email", replay: true })).body;
-    }
-    /**
-     * Where your account stands against its plan: how many small sandboxes it runs and may run
-     * at once (runningUnits; a tiny counts half, a medium 2, a large 4), what its burst meter
-     * reads against the free burst, what it has spent on burst fees this month against its
-     * budget, and what one sandbox of each size would cost to start now. With a size, and a
-     * count, quote says what starting that many now would cost.
-     *
-     * Where `enforced` is true, a create, fork or start past the running count throws an
-     * `ApiError` 429 `running_limit_reached`; one faster than the free burst costs a burst fee,
-     * and is refused with `burst_budget_reached` past the monthly budget or
-     * `burst_in_free_month` in the free month. Amounts are millionths of a US dollar.
-     */
-    async burst(quote) {
-        const query = { size: quote?.size, count: quote?.count?.toString() };
-        return (await this.http.json({ method: "GET", path: "/v1/burst", query, replay: true })).body;
-    }
-    /**
-     * Sets the most the account spends on burst fees in a month, in millionths of a US dollar:
-     * 0 refuses every start that would cost one. null gives it the default again,
-     * defaultBudgetMicros. It answers with the account's burst as it stands now.
-     */
-    async setBurstBudget(budgetMicros) {
-        return (await this.http.json({ method: "PUT", path: "/v1/burst/budget", body: { budgetMicros }, replay: true })).body;
-    }
-    /**
-     * Running time and what it comes to at the list price, by sandbox, by key, by day and by hour, and the mail of the same
-     * window. With apiKeyId, one key or several, only the sandboxes those keys made, "console" standing for those made in
-     * the console: the keys stay the whole account's.
-     */
-    async usage(options = {}) {
-        const keys = options.apiKeyId;
-        const query = { since: iso(options.since), until: iso(options.until), apiKeyId: Array.isArray(keys) ? keys.join(",") : keys };
-        return (await this.http.json({ method: "GET", path: "/v1/usage", query, replay: true })).body;
-    }
-    /**
-     * What each of your sandboxes read at one moment: now, unless at says another. A sandbox
-     * that was stopped then has a null reading, and so has one on a server that did not
-     * answer, which complete says. Only where policy() says metrics.
-     */
-    async metrics(moment = {}) {
-        return (await this.http.json({ method: "GET", path: "/v1/metrics", query: { at: iso(moment.at) }, replay: true })).body;
-    }
-    /**
-     * How many of your sandboxes were running at each step between two moments. Without
-     * since, the last 24 hours. It is counted from the record of what ran, so it answers
-     * wherever sandboxes run, and a sandbox deleted since is still counted.
-     */
-    async runningOverTime(window = {}) {
-        const query = { since: iso(window.since), until: iso(window.until), stepSeconds: window.stepSeconds?.toString() };
-        return (await this.http.json({ method: "GET", path: "/v1/metrics/running", query, replay: true })).body;
-    }
-    /**
-     * The OTLP/HTTP collector your sandboxes' metrics and lifecycle events are sent to, with
-     * the names of its headers and how the last export went. Null when none is set. Only
-     * where policy() says telemetry.
-     */
-    async getTelemetry() {
-        return (await this.http.json({ method: "GET", path: "/v1/telemetry", replay: true })).body.telemetry;
-    }
-    /**
-     * Sets the collector your sandboxes' metrics and lifecycle events are sent to, in place of
-     * the one set before. endpoint is its base address, https on port 443 or 4318. headers are
-     * sent with each export, such as the collector's API key, and their values are never
-     * shown again. Nothing is sent now: testTelemetry() does that. From the next whole minute
-     * it is sent the metrics every minute, and each event as it happens.
-     */
-    async setTelemetry(collector) {
-        const body = { endpoint: collector.endpoint, ...(collector.headers ? { headers: collector.headers } : {}) };
-        return (await this.http.json({ method: "PUT", path: "/v1/telemetry", body, replay: true })).body.telemetry;
-    }
-    /**
-     * Sends your collector one empty export, with its headers, and says what it answered. ok
-     * is false when it refused, did not answer in 10 seconds, or is at an address that is not
-     * sent to. Nothing else is changed.
-     */
-    async testTelemetry() {
-        return (await this.http.json({ method: "POST", path: "/v1/telemetry/test" })).body;
-    }
-    /** Removes your collector, with its headers, and nothing more is sent to it. When none is set it throws an ApiError with the status 404. */
-    async deleteTelemetry() {
-        await this.http.send({ method: "DELETE", path: "/v1/telemetry" });
-    }
-    /**
-     * GitHub Actions jobs on sandboxes: each repository's pool, how many sandboxes of each size it
-     * keeps and the template they are made on. available is false where jobs do not run on
-     * sandboxes here. GitHub itself is connected in the console.
-     */
-    async runsOnRepositories() {
-        return (await this.http.json({ method: "GET", path: "/v1/runs-on/repositories", replay: true })).body;
-    }
-    /**
-     * Sets a repository's pool, given as owner/name: poolMax, 1 to 50 sandboxes of each size, and
-     * templateId, one of your templates, each null for the default and left out to keep what was set.
-     * The template is used only where GitHub says the repository is private and runs no workflows
-     * from fork pull requests.
-     */
-    async setRunsOnRepository(repository, settings) {
-        return (await this.http.json({ method: "PUT", path: `/v1/runs-on/repositories/${repoPath(repository)}`, body: settings, replay: true })).body;
-    }
-    /** Puts a repository's pool back to the defaults. Its sandboxes are kept. When it has no settings it throws an ApiError with the status 404. */
-    async resetRunsOnRepository(repository) {
-        await this.http.send({ method: "DELETE", path: `/v1/runs-on/repositories/${repoPath(repository)}` });
-    }
-    /**
-     * How long your sandboxes' history is kept: the output of their commands, their agent
-     * conversations and their events. keepDays is 1, 7, 30 or 90, or null to keep it until the
-     * sandbox is deleted; 30 until you choose. retained lists what is kept for periods agental sets.
-     */
-    async getDataRetention() {
-        return (await this.http.json({ method: "GET", path: "/v1/data-retention", replay: true })).body;
-    }
-    /**
-     * Sets how long your sandboxes' history is kept: 1, 7, 30 or 90 days, or null until the
-     * sandbox is deleted. History older than that is deleted within the hour and cannot be
-     * brought back. A deleted sandbox's history is deleted with it, whatever is set, its events a day later.
-     */
-    async setDataRetention(keepDays) {
-        return (await this.http.json({ method: "PATCH", path: "/v1/data-retention", body: { keepDays }, replay: true })).body;
-    }
-    /** The webhooks your account's events are posted to, each with its tries of the last 30 days. Their secrets are not given. */
-    async listWebhooks() {
-        return (await this.http.json({ method: "GET", path: "/v1/webhooks", replay: true })).body.webhooks;
-    }
-    /**
-     * Adds a webhook. url is posted each event it takes, and has to be on the public internet.
-     * events names the kinds it takes, such as sandbox.stopped, or "*" for every one and any
-     * added later, which is what it takes when events is left out. The answer holds
-     * signingSecret, the one time it is given: each post's X-Agental-Signature is checked
-     * against it with verifyWebhook. It is sent once, so a lost answer is not sent again.
-     */
-    async createWebhook(webhook) {
-        return (await this.http.json({ method: "POST", path: "/v1/webhooks", body: webhook })).body;
-    }
-    /** One webhook, with every try of the last 30 days: the status each was answered, the event it was a try of, and which try. */
-    async getWebhook(id) {
-        return (await this.http.json({ method: "GET", path: `/v1/webhooks/${encodeURIComponent(id)}`, replay: true })).body;
-    }
-    /** Changes a webhook's url, events or description, and keeps what is left out. A changed url is used from the next try on. */
-    async updateWebhook(id, changes) {
-        return (await this.http.json({ method: "PATCH", path: `/v1/webhooks/${encodeURIComponent(id)}`, body: changes, replay: true })).body;
-    }
-    /** Gives a webhook a new signing secret, in its signingSecret, once. The old one stops working at once. */
-    async rotateWebhookSecret(id) {
-        return (await this.http.json({ method: "POST", path: `/v1/webhooks/${encodeURIComponent(id)}/rotate` })).body;
-    }
-    /** Deletes a webhook, the events still owed to it, and its tries. */
-    async deleteWebhook(id) {
-        await this.http.send({ method: "DELETE", path: `/v1/webhooks/${encodeURIComponent(id)}` });
-    }
-    /**
-     * Everything agental keeps about your account and the person behind it: the account, its
-     * sessions with the address and browser each began from, its keys by name, billing,
-     * payments, usage, and what it has made. Secrets are named, never given. Closing an
-     * account is not here: only a person signed in to the console can close one.
-     */
-    async exportAccount() {
-        return (await this.http.json({ method: "GET", path: "/v1/me/export", replay: true })).body;
-    }
-}
-/** owner/name as a path: each part encoded, the slash between them kept. */
-function repoPath(repository) {
-    const [owner, name, ...rest] = repository.split("/");
-    if (!owner || !name || rest.length > 0) {
-        throw new TypeError(`A repository is owner/name, as acme/app, and not ${JSON.stringify(repository)}.`);
-    }
-    return `${encodeURIComponent(owner)}/${encodeURIComponent(name)}`;
-}

package/dist/errors.d.ts

@@ -1,62 +0,0 @@
-/** Every error this SDK throws is one of these. */
-export declare class AgentalError extends Error {
-    constructor(message: string, options?: ErrorOptions);
-}
-/**
- * The API refused the request and said why. Decide what to do from `code`, such as
- * `sandbox_not_running` or `name_taken`. `message` says why in words.
- */
-export declare class ApiError extends AgentalError {
-    readonly status: number;
-    readonly code: string;
-    /**
-     * On a create refused with capacity_exceeded: the other regions that have room for its
-     * size now, to send it again to with a new key. Empty when none has, and undefined on
-     * any other error.
-     */
-    readonly regionsWithRoom?: string[] | undefined;
-    constructor(status: number, code: string, message: string, 
-    /**
-     * On a create refused with capacity_exceeded: the other regions that have room for its
-     * size now, to send it again to with a new key. Empty when none has, and undefined on
-     * any other error.
-     */
-    regionsWithRoom?: string[] | undefined, burst?: {
-        feeMicros?: number;
-        retryAfterSeconds?: number | null;
-    });
-    /**
-     * On a start refused with 429 for its burst (see `BurstRefusalCode`): the burst fee it
-     * would have cost, in millionths of a US dollar. Undefined on any other error.
-     */
-    readonly feeMicros?: number;
-    /**
-     * On a start refused with 429 for its burst: seconds until the same start would cost no
-     * burst fee. Null where waiting would not help: on running_limit_reached, or for a start
-     * larger than the plan's whole free burst. Undefined on any other error.
-     */
-    readonly retryAfterSeconds?: number | null;
-}
-/**
- * Why a create, fork or start was refused with the status 429. running_limit_reached: the
- * account already runs as many sandboxes as its plan's runningUnits allows. burst_fee_too_high:
- * the start would cost more in burst fees than maxBurstFeeMicros allows. burst_budget_reached:
- * the fee would take this month's burst fees past the account's budget. burst_in_free_month:
- * the start would cost a fee, which the free month does not pay.
- */
-export type BurstRefusalCode = "running_limit_reached" | "burst_fee_too_high" | "burst_budget_reached" | "burst_in_free_month";
-/**
- * Something in front of the API answered, not the API: a 502, a 504, a 52x, or any error
- * with no code in it. The API was not reached or did not answer in time, so the request
- * may still be running. Read the sandbox before sending anything but a create again.
- */
-export declare class ProxyError extends AgentalError {
-    readonly status: number;
-    constructor(status: number);
-}
-/** The API could not be reached at all. Whether the request arrived is not known. */
-export declare class ConnectionError extends AgentalError {
-}
-/** What was waited for did not happen in the time allowed. It may still happen. */
-export declare class TimeoutError extends AgentalError {
-}

package/dist/errors.js

@@ -1,65 +0,0 @@
-/** Every error this SDK throws is one of these. */
-export class AgentalError extends Error {
-    constructor(message, options) {
-        super(message, options);
-        this.name = new.target.name;
-    }
-}
-/**
- * The API refused the request and said why. Decide what to do from `code`, such as
- * `sandbox_not_running` or `name_taken`. `message` says why in words.
- */
-export class ApiError extends AgentalError {
-    status;
-    code;
-    regionsWithRoom;
-    constructor(status, code, message, 
-    /**
-     * On a create refused with capacity_exceeded: the other regions that have room for its
-     * size now, to send it again to with a new key. Empty when none has, and undefined on
-     * any other error.
-     */
-    regionsWithRoom, burst) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.regionsWithRoom = regionsWithRoom;
-        if (burst?.feeMicros !== undefined) {
-            this.feeMicros = burst.feeMicros;
-        }
-        if (burst?.retryAfterSeconds !== undefined) {
-            this.retryAfterSeconds = burst.retryAfterSeconds;
-        }
-    }
-    /**
-     * On a start refused with 429 for its burst (see `BurstRefusalCode`): the burst fee it
-     * would have cost, in millionths of a US dollar. Undefined on any other error.
-     */
-    feeMicros;
-    /**
-     * On a start refused with 429 for its burst: seconds until the same start would cost no
-     * burst fee. Null where waiting would not help: on running_limit_reached, or for a start
-     * larger than the plan's whole free burst. Undefined on any other error.
-     */
-    retryAfterSeconds;
-}
-/**
- * Something in front of the API answered, not the API: a 502, a 504, a 52x, or any error
- * with no code in it. The API was not reached or did not answer in time, so the request
- * may still be running. Read the sandbox before sending anything but a create again.
- */
-export class ProxyError extends AgentalError {
-    status;
-    constructor(status) {
-        super(status >= 500
-            ? `HTTP ${status} from a proxy in front of the API, not from the API. The request may still be running.`
-            : `HTTP ${status} with no error of the API's in it. Check that baseUrl is where the API answers.`);
-        this.status = status;
-    }
-}
-/** The API could not be reached at all. Whether the request arrived is not known. */
-export class ConnectionError extends AgentalError {
-}
-/** What was waited for did not happen in the time allowed. It may still happen. */
-export class TimeoutError extends AgentalError {
-}

package/dist/http.d.ts

@@ -1,69 +0,0 @@
-export declare const DEFAULT_BASE_URL = "https://agental.io";
-export interface AgentalOptions {
-    /**
-     * Your API key. Left out, it is read from the environment variable AGENTAL_API_KEY, or else
-     * from the sign-in the agental command keeps on this computer (`npx agental@latest`).
-     */
-    apiKey?: string;
-    /** Where the API answers. Left out, it is AGENTAL_API_URL, or the API the agental command signed in to, or https://agental.io. */
-    baseUrl?: string;
-    /** What requests are sent with. Left out, it is the runtime's own fetch. */
-    fetch?: typeof fetch;
-    /** How many times a request that is safe to send again is sent again. Default 3. */
-    maxRetries?: number;
-    /** The shortest wait before a request is sent again, in milliseconds. Default 1000. */
-    retryDelayMs?: number;
-    /** How often something that is waited for is looked at, in milliseconds. Default 2000. */
-    pollIntervalMs?: number;
-}
-export interface Call {
-    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-    path: string;
-    query?: Record<string, string | readonly string[] | undefined>;
-    body?: unknown;
-    headers?: Record<string, string>;
-    /**
-     * Whether sending it twice does what sending it once does. Only such a request is sent
-     * again by itself: a read, a create with its key, a file write. A command is not.
-     */
-    replay?: boolean;
-    signal?: AbortSignal;
-}
-export interface StreamEvent {
-    event: string;
-    data: unknown;
-}
-export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
-/** Sends requests to the API, and sends again the ones that are safe to. */
-export declare class Http {
-    readonly pollIntervalMs: number;
-    private readonly apiKey;
-    private readonly baseUrl;
-    private readonly fetch;
-    private readonly maxRetries;
-    private readonly retryDelayMs;
-    constructor(options?: AgentalOptions);
-    /** The answer to a request that worked. One that did not is thrown, after it was sent again if that was safe. */
-    send(call: Call): Promise<Response>;
-    /** The JSON a request was answered with, and the status and headers it came with. */
-    json<T>(call: Call): Promise<{
-        status: number;
-        body: T;
-        headers: Headers;
-    }>;
-    /** The server-sent events a request is answered with, each as it arrives. */
-    events(call: Call): AsyncGenerator<StreamEvent, void, void>;
-    /**
-     * How long to wait before a failed request is sent again, or null when it is not to be.
-     * The waits are the ones the API asks for: a request cut off by a move is sent again at
-     * once, a move under way is waited out, and a proxy or a failing host is given ten times
-     * the shortest wait. Only a request that may be sent twice is sent again, except one the
-     * API turned away as it restarted: nothing was done with that one, a command neither.
-     */
-    private waitBefore;
-}
-/**
- * A tag as a part of a path: lowercased and trimmed as the API would, and refused here when it
- * is not one, so that no word, "..", say, can make the path another.
- */
-export declare function tagSegment(tag: string): string;