daishi-sdk 0.1.0

package/dist/generated.js

@@ -0,0 +1,367 @@
+// Generated from the Daishi Studio API's OpenAPI document, https://daishi.ai/api/v1/openapi.json. Do not edit.
+/* eslint-disable */
+/** The API version these types describe. */
+export const API_VERSION = '1.0.0';
+/** One method per API operation. The transport is the subclass's. */
+export class Operations {
+    /**
+     * API index.
+     *
+     * Discover the API without a token: endpoints, docs, the MCP path.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-index
+     */
+    index() {
+        return this.request('GET', '/');
+    }
+    /**
+     * OpenAPI document.
+     *
+     * The API as an OpenAPI 3.1 document, for generators and API clients.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-openapi
+     */
+    openapi() {
+        return this.request('GET', '/openapi.json');
+    }
+    /**
+     * Who am I.
+     *
+     * The account, plan, this token’s scopes and the limits that bound scenarios and runs.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-me
+     */
+    me() {
+        return this.request('GET', '/me');
+    }
+    /**
+     * Scenario schema.
+     *
+     * JSON Schema (draft 2020-12) for a scenario body, with the live resource types and anchor ids.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-schema
+     */
+    schema() {
+        return this.request('GET', '/scenarios/schema');
+    }
+    /**
+     * Library scenarios.
+     *
+     * The scenarios the platform ships. Any of their ids can be launched directly.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-library-scenarios
+     */
+    libraryScenarios() {
+        return this.request('GET', '/library/scenarios');
+    }
+    /**
+     * Anchor bots.
+     *
+     * Baseline bot policies and populations a scenario may field as `env.anchors`.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-library-anchors
+     */
+    libraryAnchors() {
+        return this.request('GET', '/library/anchors');
+    }
+    /**
+     * Validate a scenario.
+     *
+     * Dry run: the normalized definition, its content hash and the plan receipt. Nothing is saved.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-validate
+     */
+    validate(body) {
+        return this.request('POST', '/scenarios/validate', { body });
+    }
+    /**
+     * List your scenarios.
+     *
+     * Every scenario saved on the account, newest first.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-scenarios
+     */
+    listScenarios() {
+        return this.request('GET', '/scenarios');
+    }
+    /**
+     * Create a scenario.
+     *
+     * Save a scenario. Idempotent on name plus content hash.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-create-scenario
+     */
+    createScenario(body) {
+        return this.request('POST', '/scenarios', { body });
+    }
+    /**
+     * Get a scenario.
+     *
+     * One saved scenario by id.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-scenario
+     */
+    getScenario(id) {
+        return this.request('GET', `/scenarios/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Update a scenario.
+     *
+     * Edit a saved scenario in place. Omitted fields keep their value.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-update-scenario
+     */
+    updateScenario(id, body) {
+        return this.request('PUT', `/scenarios/${encodeURIComponent(id)}`, { body });
+    }
+    /**
+     * Delete a scenario.
+     *
+     * Remove a saved scenario. Played runs keep their snapshot.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-delete-scenario
+     */
+    deleteScenario(id) {
+        return this.request('DELETE', `/scenarios/${encodeURIComponent(id)}`);
+    }
+    /**
+     * List skills.
+     *
+     * The built-in skills, your own, and the authoring bounds.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-skills
+     */
+    listSkills() {
+        return this.request('GET', '/skills');
+    }
+    /**
+     * Create a skill.
+     *
+     * Save a prompt module on the account.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-create-skill
+     */
+    createSkill(body) {
+        return this.request('POST', '/skills', { body });
+    }
+    /**
+     * Get a skill.
+     *
+     * One skill by id: a built-in or one of yours.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-skill
+     */
+    getSkill(id) {
+        return this.request('GET', `/skills/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Update a skill.
+     *
+     * Edit in place. Omitted fields keep their value.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-update-skill
+     */
+    updateSkill(id, body) {
+        return this.request('PUT', `/skills/${encodeURIComponent(id)}`, { body });
+    }
+    /**
+     * Delete a skill.
+     *
+     * Remove one of your skills. Played runs keep their snapshot.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-delete-skill
+     */
+    deleteSkill(id) {
+        return this.request('DELETE', `/skills/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Estimate a run.
+     *
+     * What a launch of this body would cost and commit, or the refusal it would get. Nothing is queued.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-estimate
+     */
+    estimate(body) {
+        return this.request('POST', '/runs/estimate', { body });
+    }
+    /**
+     * Launch a run.
+     *
+     * Queue a run, or a series batch when `trials` is above 1.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-launch
+     */
+    launch(body) {
+        return this.request('POST', '/runs', { body });
+    }
+    /**
+     * List your runs.
+     *
+     * Your runs, newest first.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-runs
+     */
+    listRuns(query = {}) {
+        return this.request('GET', '/runs', { query });
+    }
+    /**
+     * Get a run.
+     *
+     * One run: status, the as-played configuration and, once finished, the scored results per seat.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-run
+     */
+    getRun(id) {
+        return this.request('GET', `/runs/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Usage and allowances.
+     *
+     * The meter’s record of your runs and where the account stands against the plan this month.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-usage
+     */
+    usage() {
+        return this.request('GET', '/usage');
+    }
+    /**
+     * Live worlds.
+     *
+     * Every world your account has playing right now, as small boards, and every run waiting for one.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-live
+     */
+    live() {
+        return this.request('GET', '/live');
+    }
+    /**
+     * Get a batch report.
+     *
+     * A series batch as one report: per-model intervals, survival, cost, every trial, and a verdict.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-batch
+     */
+    getBatch(id) {
+        return this.request('GET', `/batches/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Estimate an experiment.
+     *
+     * What creating this experiment would cost and check against, or the refusal it would get. Nothing is queued.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-estimate-experiment
+     */
+    estimateExperiment(body) {
+        return this.request('POST', '/experiments/estimate', { body });
+    }
+    /**
+     * Create an experiment.
+     *
+     * Queue a paired experiment: two to four arms of one scenario on shared seeds, under a stopping rule.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-create-experiment
+     */
+    createExperiment(body) {
+        return this.request('POST', '/experiments', { body });
+    }
+    /**
+     * List your experiments.
+     *
+     * Your experiments, newest first, with the verdict on record.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-experiments
+     */
+    listExperiments() {
+        return this.request('GET', '/experiments');
+    }
+    /**
+     * Get an experiment report.
+     *
+     * The paired report as scored right now: per arm, per pair, each comparison against the control, the decision and a verdict.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-get-experiment
+     */
+    getExperiment(id) {
+        return this.request('GET', `/experiments/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Cancel an experiment.
+     *
+     * Stop a queued or running experiment: every unfinished trial of every arm, then the record.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-cancel-experiment
+     */
+    cancelExperiment(id) {
+        return this.request('POST', `/experiments/${encodeURIComponent(id)}/cancel`);
+    }
+    /**
+     * Cancel a run.
+     *
+     * Stop a queued or running run.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-cancel
+     */
+    cancel(id) {
+        return this.request('POST', `/runs/${encodeURIComponent(id)}/cancel`);
+    }
+    /**
+     * List a run’s logs.
+     *
+     * The harness log files kept for one of your runs, with their sizes and how long they are kept.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-run-logs
+     */
+    runLogs(id) {
+        return this.request('GET', `/runs/${encodeURIComponent(id)}/logs`);
+    }
+    /**
+     * Read a run log.
+     *
+     * One log file, as the JSONL the harness wrote.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-run-log
+     */
+    runLog(id, file) {
+        return this.request('GET', `/runs/${encodeURIComponent(id)}/logs/${encodeURIComponent(file)}`, { text: true });
+    }
+    /**
+     * List a run’s guest seats.
+     *
+     * Every guest seat of one of your world runs: its link, its state and who claimed it.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-list-invites
+     */
+    listInvites(id) {
+        return this.request('GET', `/runs/${encodeURIComponent(id)}/invites`);
+    }
+    /**
+     * Extend the signup window.
+     *
+     * Move every open seat’s claim-by deadline to `minutes` from now.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-extend-invites
+     */
+    extendInvites(id, body) {
+        return this.request('POST', `/runs/${encodeURIComponent(id)}/invites/extend`, { body });
+    }
+    /**
+     * Regenerate a seat’s link.
+     *
+     * A fresh link for one seat; the old token stops resolving at once.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-regenerate-invite
+     */
+    regenerateInvite(id, inviteId) {
+        return this.request('POST', `/runs/${encodeURIComponent(id)}/invites/${encodeURIComponent(inviteId)}/regenerate`);
+    }
+    /**
+     * Withdraw a seat.
+     *
+     * Withdraw one guest seat: its link stops resolving and the seat leaves the roster at launch.
+     *
+     * @see https://daishi.ai/docs/developer/rest#ep-revoke-invite
+     */
+    revokeInvite(id, inviteId) {
+        return this.request('POST', `/runs/${encodeURIComponent(id)}/invites/${encodeURIComponent(inviteId)}/revoke`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+import { Operations, type ErrorCode, type GetBatchResponse, type GetExperimentResponse, type GetRunResponse, type Method, type RequestParts } from './generated.js';
+export * from './generated.js';
+export declare const VERSION = "0.1.0";
+export declare const DEFAULT_BASE_URL = "https://daishi.ai/api/v1";
+export interface DaishiOptions {
+    /** A Studio access token (`dsk_...`). Default: the `DAISHI_TOKEN` environment variable. */
+    token?: string;
+    /** Default: `https://daishi.ai/api/v1`. */
+    baseUrl?: string;
+    /** Retries after a refusal that is safe to repeat. Default 3; 0 turns retrying off. */
+    maxRetries?: number;
+    /** Per-attempt timeout in milliseconds. Default 60000. */
+    timeoutMs?: number;
+    /** A fetch implementation. Default: the global one (Node 18+, browsers, Deno, Bun). */
+    fetch?: typeof fetch;
+}
+export interface WaitOptions<T> {
+    /** Milliseconds between polls. Default 30000. */
+    intervalMs?: number;
+    /** Stops the wait; `AbortSignal.timeout(ms)` gives it a deadline. */
+    signal?: AbortSignal;
+    /** Called with every poll's answer, the last one included. */
+    onPoll?: (answer: T) => void;
+}
+/** A refusal from the API, or a transport failure after the retries ran out. */
+export declare class DaishiError extends Error {
+    /** HTTP status; 0 when no response arrived. */
+    readonly status: number;
+    /** The API's error code (`unknown_run`, `rate_limited`, ...), or `http_<status>` when the body carried none. */
+    readonly code: ErrorCode | (string & {});
+    /** Seconds the `Retry-After` header asked for, when it sent one. */
+    readonly retryAfterSeconds: number | null;
+    /** The parsed error body, when there was one. */
+    readonly body: unknown;
+    readonly name = "DaishiError";
+    constructor(
+    /** HTTP status; 0 when no response arrived. */
+    status: number, 
+    /** The API's error code (`unknown_run`, `rate_limited`, ...), or `http_<status>` when the body carried none. */
+    code: ErrorCode | (string & {}), message: string, 
+    /** Seconds the `Retry-After` header asked for, when it sent one. */
+    retryAfterSeconds?: number | null, 
+    /** The parsed error body, when there was one. */
+    body?: unknown);
+    /** Where the code is explained. */
+    get docs(): string;
+}
+/**
+ * The Daishi Studio API. Every operation is a method (`getRun`, `launch`,
+ * `createScenario`, ...) typed from the API's OpenAPI document; the
+ * `waitFor*` helpers poll until a run, batch or experiment ends.
+ *
+ * Retries: a 429 is retried after the seconds its `Retry-After` names, and
+ * a `run_launching` refusal after a short pause, on any method, because the
+ * server refused before doing anything. A gateway error (502, 503, 504) or
+ * a dropped connection is retried on GET only: a write that may have landed
+ * is never sent twice.
+ */
+export declare class Daishi extends Operations {
+    readonly baseUrl: string;
+    private readonly token;
+    private readonly maxRetries;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(options?: DaishiOptions);
+    protected request<T>(method: Method, path: string, parts?: RequestParts): Promise<T>;
+    /**
+     * Polls a run until it ends (finished, failed or cancelled) and answers
+     * with the last read. A finished run is read until its `results` arrive,
+     * which is when the match archives.
+     */
+    waitForRun(id: string, options?: WaitOptions<GetRunResponse>): Promise<GetRunResponse>;
+    /** Polls a series batch until no trial is still to play. */
+    waitForBatch(id: string, options?: WaitOptions<GetBatchResponse>): Promise<GetBatchResponse>;
+    /** Polls a paired experiment until it finishes or is cancelled. */
+    waitForExperiment(id: string, options?: WaitOptions<GetExperimentResponse>): Promise<GetExperimentResponse>;
+    private poll;
+}

package/dist/index.js

@@ -0,0 +1,165 @@
+import { Operations } from './generated.js';
+export * from './generated.js';
+export const VERSION = '0.1.0';
+export const DEFAULT_BASE_URL = 'https://daishi.ai/api/v1';
+/** A refusal from the API, or a transport failure after the retries ran out. */
+export class DaishiError extends Error {
+    status;
+    code;
+    retryAfterSeconds;
+    body;
+    name = 'DaishiError';
+    constructor(
+    /** HTTP status; 0 when no response arrived. */
+    status, 
+    /** The API's error code (`unknown_run`, `rate_limited`, ...), or `http_<status>` when the body carried none. */
+    code, message, 
+    /** Seconds the `Retry-After` header asked for, when it sent one. */
+    retryAfterSeconds = null, 
+    /** The parsed error body, when there was one. */
+    body = null) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.body = body;
+    }
+    /** Where the code is explained. */
+    get docs() {
+        return `https://daishi.ai/docs/developer/errors#${this.code}`;
+    }
+}
+const RUN_DONE = new Set(['finished', 'failed', 'cancelled']);
+const EXPERIMENT_DONE = new Set(['finished', 'cancelled']);
+const GATEWAY = new Set([502, 503, 504]);
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+        return reject(signal.reason);
+    const t = setTimeout(() => {
+        signal?.removeEventListener('abort', onAbort);
+        resolve();
+    }, ms);
+    const onAbort = () => {
+        clearTimeout(t);
+        reject(signal.reason);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+});
+function envToken() {
+    const env = globalThis.process?.env;
+    return env?.DAISHI_TOKEN || undefined;
+}
+/**
+ * The Daishi Studio API. Every operation is a method (`getRun`, `launch`,
+ * `createScenario`, ...) typed from the API's OpenAPI document; the
+ * `waitFor*` helpers poll until a run, batch or experiment ends.
+ *
+ * Retries: a 429 is retried after the seconds its `Retry-After` names, and
+ * a `run_launching` refusal after a short pause, on any method, because the
+ * server refused before doing anything. A gateway error (502, 503, 504) or
+ * a dropped connection is retried on GET only: a write that may have landed
+ * is never sent twice.
+ */
+export class Daishi extends Operations {
+    baseUrl;
+    token;
+    maxRetries;
+    timeoutMs;
+    fetchImpl;
+    constructor(options = {}) {
+        super();
+        this.token = options.token ?? envToken();
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.maxRetries = options.maxRetries ?? 3;
+        this.timeoutMs = options.timeoutMs ?? 60_000;
+        const f = options.fetch ?? globalThis.fetch;
+        if (!f)
+            throw new Error('No fetch implementation: use Node 18 or later, or pass options.fetch.');
+        this.fetchImpl = f.bind(globalThis);
+    }
+    async request(method, path, parts = {}) {
+        const url = new URL(this.baseUrl + (path === '/' ? '' : path));
+        for (const [k, v] of Object.entries(parts.query ?? {}))
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        const headers = { accept: parts.text ? 'application/x-ndjson, application/json' : 'application/json' };
+        if (this.token)
+            headers.authorization = `Bearer ${this.token}`;
+        if (parts.body !== undefined)
+            headers['content-type'] = 'application/json';
+        const body = parts.body !== undefined ? JSON.stringify(parts.body) : undefined;
+        for (let attempt = 0;; attempt++) {
+            const canRetry = attempt < this.maxRetries;
+            let res;
+            try {
+                res = await this.fetchImpl(url, { method, headers, body, signal: AbortSignal.timeout(this.timeoutMs) });
+            }
+            catch (err) {
+                if (method === 'GET' && canRetry) {
+                    await sleep(backoffMs(attempt));
+                    continue;
+                }
+                throw new DaishiError(0, 'network_error', `${method} ${url.pathname} failed: ${err.message ?? String(err)}`, null, null);
+            }
+            if (res.ok)
+                return (parts.text ? await res.text() : await res.json());
+            const text = await res.text();
+            let parsed = null;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = null;
+            }
+            const code = parsed?.error ?? `http_${res.status}`;
+            const retryAfter = parseRetryAfter(res.headers.get('retry-after'));
+            const retryable = res.status === 429 || code === 'run_launching' || (method === 'GET' && GATEWAY.has(res.status));
+            if (retryable && canRetry) {
+                await sleep(retryAfter !== null ? retryAfter * 1000 : backoffMs(attempt));
+                continue;
+            }
+            throw new DaishiError(res.status, code, parsed?.message ?? (text.slice(0, 200) || res.statusText), retryAfter, parsed);
+        }
+    }
+    /**
+     * Polls a run until it ends (finished, failed or cancelled) and answers
+     * with the last read. A finished run is read until its `results` arrive,
+     * which is when the match archives.
+     */
+    waitForRun(id, options = {}) {
+        return this.poll(() => this.getRun(id), (r) => RUN_DONE.has(r.run.status) && (r.run.status !== 'finished' || r.results !== null), options);
+    }
+    /** Polls a series batch until no trial is still to play. */
+    waitForBatch(id, options = {}) {
+        return this.poll(() => this.getBatch(id), (r) => r.batch.pending === 0, options);
+    }
+    /** Polls a paired experiment until it finishes or is cancelled. */
+    waitForExperiment(id, options = {}) {
+        return this.poll(() => this.getExperiment(id), (r) => EXPERIMENT_DONE.has(r.experiment.status), options);
+    }
+    async poll(read, done, options) {
+        const interval = options.intervalMs ?? 30_000;
+        for (;;) {
+            options.signal?.throwIfAborted();
+            const answer = await read();
+            options.onPoll?.(answer);
+            if (done(answer))
+                return answer;
+            await sleep(interval, options.signal);
+        }
+    }
+}
+function parseRetryAfter(header) {
+    if (!header)
+        return null;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds;
+    const at = Date.parse(header);
+    return Number.isNaN(at) ? null : Math.max(0, Math.ceil((at - Date.now()) / 1000));
+}
+/** 1 s, 2 s, 4 s ... with up to a quarter of jitter, capped at 30 s. */
+function backoffMs(attempt) {
+    const base = Math.min(30_000, 1000 * 2 ** attempt);
+    return base + Math.floor(Math.random() * base * 0.25);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "daishi-sdk",
+  "version": "0.1.0",
+  "description": "Typed client for the Daishi Studio API: scenarios, runs, series batches and paired experiments, with retries and waiting helpers.",
+  "keywords": [
+    "daishi",
+    "ai",
+    "agents",
+    "evaluation",
+    "benchmark",
+    "llm",
+    "multi-agent"
+  ],
+  "homepage": "https://daishi.ai/docs/developer",
+  "license": "MIT",
+  "author": "Arkeous LLC",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  }
+}