@agent-api/sdk 1.1.3 → 1.1.5

package/dist-cjs/local-skills.js

@@ -0,0 +1,308 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localSkillFromDirectory = localSkillFromDirectory;
+exports.pendingLocalSkillCalls = pendingLocalSkillCalls;
+exports.runLocalSkillHandlers = runLocalSkillHandlers;
+const local_functions_js_1 = require("./local-functions.js");
+const DEFAULT_FOCUS_MANIFEST_CHARS = 16000;
+const DEFAULT_FOCUS_FILE_CHARS = 12000;
+async function localSkillFromDirectory(rootDir, options = {}) {
+    const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const crypto = await Promise.resolve().then(() => __importStar(require("node:crypto")));
+    const root = path.resolve(rootDir);
+    const files = await walkFiles(fs, path, root, root);
+    const hash = crypto.createHash("sha256");
+    for (const rel of files.sort()) {
+        hash.update(rel);
+        hash.update("\0");
+        hash.update(await fs.readFile(path.join(root, rel)));
+        hash.update("\0");
+    }
+    const digest = "sha256:" + hash.digest("hex");
+    const base = path.basename(root);
+    const localSkillID = options.id ?? base;
+    const { manifest, manifestTruncated } = await readLocalManifest(fs, path, root, options.max_manifest_chars ?? DEFAULT_FOCUS_MANIFEST_CHARS);
+    return {
+        local_skill_id: localSkillID,
+        skill_ref: skillRefForLocal(localSkillID, digest),
+        name: options.name ?? base,
+        description: options.description,
+        root_hint: root,
+        digest,
+        manifest,
+        manifest_truncated: manifestTruncated,
+        metadata: options.metadata,
+    };
+}
+function pendingLocalSkillCalls(response) {
+    return (0, local_functions_js_1.pendingFunctionCalls)(response).filter((call) => isLocalSkillFocusCall(call));
+}
+function isLocalSkillFocusCall(call) {
+    if (call.name !== "skill") {
+        return false;
+    }
+    try {
+        const args = call.arguments ? JSON.parse(call.arguments) : {};
+        return String(args.action || "").trim().toLowerCase() === "focus";
+    }
+    catch {
+        return false;
+    }
+}
+async function runLocalSkillHandlers(response, localSkills) {
+    const byRef = await localSkillsByRef(localSkills);
+    const outputs = [];
+    for (const call of pendingLocalSkillCalls(response)) {
+        const args = call.arguments ? JSON.parse(call.arguments) : {};
+        const payload = await focusLocalSkills(args, byRef);
+        outputs.push((0, local_functions_js_1.functionCallOutputInput)(call.call_id, payload));
+    }
+    return outputs;
+}
+async function focusLocalSkills(args, byRef) {
+    const maxManifestChars = manifestCharLimit(args);
+    const maxFileChars = fileCharLimit(args);
+    const items = Array.isArray(args.skills) ? args.skills : [];
+    if (!Array.isArray(args.skills)) {
+        return { data: [{ ok: false, error: { code: "invalid_skill_focus", message: "skills must be an array" } }] };
+    }
+    const data = [];
+    for (const raw of items) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            data.push({ ok: false, error: { code: "invalid_skill_focus", message: "skill item must be an object" } });
+            continue;
+        }
+        const item = raw;
+        const skillRef = String(item.skill_ref || "").trim();
+        const result = { ok: false, skill_ref: skillRef, branch: "main" };
+        const descriptor = byRef.get(skillRef);
+        if (!descriptor) {
+            result.error = { code: "skill_ref_not_found", message: "skill_ref was not registered with the SDK" };
+            data.push(result);
+            continue;
+        }
+        try {
+            result.skill = await focusedLocalSkill(descriptor, maxManifestChars, pathsArg(item), maxFileChars, includeManifest(item));
+            result.ok = true;
+        }
+        catch (error) {
+            result.error = { code: "local_skill_focus_failed", message: error instanceof Error ? error.message : String(error) };
+        }
+        data.push(result);
+    }
+    return { data };
+}
+async function focusedLocalSkill(descriptor, maxManifestChars, paths, maxFileChars, includeManifest) {
+    const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const { TextDecoder } = await Promise.resolve().then(() => __importStar(require("node:util")));
+    const root = path.resolve(descriptor.root_hint || ".");
+    const stat = await fs.stat(root);
+    if (!stat.isDirectory()) {
+        throw new Error(`local skill root is not a directory: ${root}`);
+    }
+    let manifest = "";
+    let manifestTruncated = false;
+    if (includeManifest) {
+        try {
+            const manifestBytes = await fs.readFile(path.join(root, "SKILL.md"));
+            manifest = new TextDecoder("utf-8", { fatal: true }).decode(manifestBytes);
+            const manifestChars = Array.from(manifest);
+            if (maxManifestChars > 0 && manifestChars.length > maxManifestChars) {
+                manifest = manifestChars.slice(0, maxManifestChars).join("");
+                manifestTruncated = true;
+            }
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    const dirents = await fs.readdir(root, { withFileTypes: true });
+    const entries = await Promise.all(dirents
+        .filter((entry) => ![".git", "__pycache__", "node_modules"].includes(entry.name))
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(async (entry) => {
+        const full = path.join(root, entry.name);
+        const entryStat = await fs.stat(full);
+        return {
+            path: entry.name,
+            is_dir: entry.isDirectory(),
+            size: entry.isDirectory() ? 0 : entryStat.size,
+            modified_at: Math.floor(entryStat.mtimeMs / 1000),
+        };
+    }));
+    return {
+        skill_ref: await descriptorSkillRef(descriptor),
+        name: descriptor.name || "",
+        description: descriptor.description || "",
+        branch: "SKILL_BRANCH_MAIN",
+        digest: descriptor.digest || "",
+        manifest,
+        manifest_truncated: manifestTruncated,
+        entries,
+        files: await Promise.all(paths.map((relPath) => focusedLocalFile(fs, path, root, relPath, maxFileChars))),
+    };
+}
+function manifestCharLimit(args) {
+    const raw = args.max_manifest_chars ?? DEFAULT_FOCUS_MANIFEST_CHARS;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : DEFAULT_FOCUS_MANIFEST_CHARS;
+}
+function fileCharLimit(args) {
+    const raw = args.max_file_chars ?? DEFAULT_FOCUS_FILE_CHARS;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : DEFAULT_FOCUS_FILE_CHARS;
+}
+function pathsArg(item) {
+    if (!Array.isArray(item.paths)) {
+        return [];
+    }
+    return item.paths
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim())
+        .filter(Boolean);
+}
+function includeManifest(item) {
+    return typeof item.include_manifest === "boolean" ? item.include_manifest : true;
+}
+async function focusedLocalFile(fs, path, root, relPath, maxFileChars) {
+    const base = { path: relPath, branch: "SKILL_BRANCH_MAIN", content: "", truncated: false, size: 0 };
+    const { TextDecoder } = await Promise.resolve().then(() => __importStar(require("node:util")));
+    try {
+        const full = path.resolve(root, relPath);
+        const relative = path.relative(root, full);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            return { ...base, error: { type: "skill_error", code: "invalid_skill_file_path", message: "path must stay inside the local skill root" } };
+        }
+        const stat = await fs.stat(full);
+        if (!stat.isFile()) {
+            return { ...base, error: { type: "skill_error", code: "skill_file_not_found", message: "skill file was not found" } };
+        }
+        const raw = await fs.readFile(full);
+        let content = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        let truncated = false;
+        const chars = Array.from(content);
+        if (maxFileChars > 0 && chars.length > maxFileChars) {
+            content = chars.slice(0, maxFileChars).join("");
+            truncated = true;
+        }
+        return { ...base, content, truncated, size: stat.size };
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return { ...base, error: { type: "skill_error", code: "skill_file_not_found", message: "skill file was not found" } };
+        }
+        if (error instanceof TypeError) {
+            return { ...base, error: { type: "skill_error", code: "invalid_skill_file_utf8", message: "skill file must be valid UTF-8" } };
+        }
+        return { ...base, error: { type: "skill_error", code: "skill_file_read_failed", message: error instanceof Error ? error.message : String(error) } };
+    }
+}
+async function walkFiles(fs, path, root, dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        if (entry.name === ".git" || entry.name === "node_modules") {
+            continue;
+        }
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...await walkFiles(fs, path, root, full));
+            continue;
+        }
+        if (entry.isFile()) {
+            out.push(path.relative(root, full).split(path.sep).join("/"));
+        }
+    }
+    return out;
+}
+async function localSkillsByRef(localSkills) {
+    const out = new Map();
+    for (const skill of localSkills) {
+        out.set(await descriptorSkillRef(skill), skill);
+    }
+    return out;
+}
+async function descriptorSkillRef(descriptor) {
+    const existing = String(descriptor.skill_ref || "").trim();
+    if (existing) {
+        return existing;
+    }
+    return skillRefForLocal(descriptor.local_skill_id || "", descriptor.digest || "");
+}
+function skillRefForLocal(localSkillID, digest) {
+    const slug = skillRefSlug(localSkillID) || "local-skill";
+    const digestPart = skillRefDigestPart(digest) || "unknown";
+    return `local::${slug}@${digestPart}::main`;
+}
+function skillRefSlug(raw) {
+    return raw
+        .trim()
+        .toLowerCase()
+        .replace(/::/g, "-")
+        .replace(/@/g, "-")
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^[-_]+|[-_]+$/g, "")
+        .slice(0, 64)
+        .replace(/^[-_]+|[-_]+$/g, "");
+}
+function skillRefDigestPart(raw) {
+    const digest = raw.trim().toLowerCase().split(":").pop() || "";
+    return digest.replace(/[^a-z0-9_-]+/g, "").slice(0, 16);
+}
+async function readLocalManifest(fs, path, root, maxManifestChars) {
+    const { TextDecoder } = await Promise.resolve().then(() => __importStar(require("node:util")));
+    try {
+        const raw = await fs.readFile(path.join(root, "SKILL.md"));
+        let manifest = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        let manifestTruncated = false;
+        const chars = Array.from(manifest);
+        if (maxManifestChars > 0 && chars.length > maxManifestChars) {
+            manifest = chars.slice(0, maxManifestChars).join("");
+            manifestTruncated = true;
+        }
+        return { manifest, manifestTruncated };
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return { manifest: "", manifestTruncated: false };
+        }
+        throw error;
+    }
+}

package/dist-cjs/node-client.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeAgentAPI = void 0;
+const client_js_1 = require("./client.js");
+const skills_node_js_1 = require("./resources/skills-node.js");
+class NodeAgentAPI extends client_js_1.AgentAPI {
+    createSkillsResource() {
+        return new skills_node_js_1.NodeSkillsResource(this.http);
+    }
+}
+exports.NodeAgentAPI = NodeAgentAPI;

package/dist-cjs/node.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLocalSkillHandlers = exports.pendingLocalSkillCalls = exports.localSkillFromDirectory = exports.localWorkspaceToolInstructions = exports.localWorkspaceToolDefinition = exports.createLocalWorkspaceToolRegistry = exports.LocalWorkspaceDriver = exports.NodeSkillsResource = exports.NodeAgentAPI = void 0;
+__exportStar(require("./index.js"), exports);
+var node_client_js_1 = require("./node-client.js");
+Object.defineProperty(exports, "NodeAgentAPI", { enumerable: true, get: function () { return node_client_js_1.NodeAgentAPI; } });
+var skills_node_js_1 = require("./resources/skills-node.js");
+Object.defineProperty(exports, "NodeSkillsResource", { enumerable: true, get: function () { return skills_node_js_1.NodeSkillsResource; } });
+var tools_js_1 = require("./local/tools.js");
+Object.defineProperty(exports, "LocalWorkspaceDriver", { enumerable: true, get: function () { return tools_js_1.LocalWorkspaceDriver; } });
+Object.defineProperty(exports, "createLocalWorkspaceToolRegistry", { enumerable: true, get: function () { return tools_js_1.createLocalWorkspaceToolRegistry; } });
+Object.defineProperty(exports, "localWorkspaceToolDefinition", { enumerable: true, get: function () { return tools_js_1.localWorkspaceToolDefinition; } });
+Object.defineProperty(exports, "localWorkspaceToolInstructions", { enumerable: true, get: function () { return tools_js_1.localWorkspaceToolInstructions; } });
+var local_skills_js_1 = require("./local-skills.js");
+Object.defineProperty(exports, "localSkillFromDirectory", { enumerable: true, get: function () { return local_skills_js_1.localSkillFromDirectory; } });
+Object.defineProperty(exports, "pendingLocalSkillCalls", { enumerable: true, get: function () { return local_skills_js_1.pendingLocalSkillCalls; } });
+Object.defineProperty(exports, "runLocalSkillHandlers", { enumerable: true, get: function () { return local_skills_js_1.runLocalSkillHandlers; } });
+__exportStar(require("./local/index.js"), exports);

package/dist-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist-cjs/pagination.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+exports.collectPage = collectPage;
+class Page {
+    fetchPage;
+    params;
+    data;
+    hasMore;
+    nextPageToken;
+    constructor(fetchPage, params, data, hasMore, nextPageToken) {
+        this.fetchPage = fetchPage;
+        this.params = params;
+        this.data = data;
+        this.hasMore = hasMore;
+        this.nextPageToken = nextPageToken;
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterateAll()[Symbol.asyncIterator]();
+    }
+    async getNextPage() {
+        if (!this.hasMore || !this.nextPageToken) {
+            return null;
+        }
+        const nextParams = { ...this.params, page_token: this.nextPageToken };
+        const result = await this.fetchPage(nextParams);
+        return new Page(this.fetchPage, nextParams, result.data, result.has_more, result.next_page_token);
+    }
+    async *iterateAll() {
+        let page = this;
+        while (page) {
+            for (const item of page.data) {
+                yield item;
+            }
+            page = await page.getNextPage();
+        }
+    }
+}
+exports.Page = Page;
+async function collectPage(fetchPage, params) {
+    const result = await fetchPage(params);
+    return new Page(fetchPage, params, result.data, result.has_more, result.next_page_token);
+}

package/dist-cjs/preset-tools.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePresetTools = resolvePresetTools;
+exports.resolvePresetToolsFromCatalog = resolvePresetToolsFromCatalog;
+exports.mergeTools = mergeTools;
+exports.publicToolToRequestTool = publicToolToRequestTool;
+const tool_validation_js_1 = require("./tool-validation.js");
+/**
+ * Resolve a preset's allowed tool names into concrete request tools and append
+ * caller-provided tools. This is a convenience for hybrid apps that need to add
+ * local/client tools while preserving the preset's default server tools.
+ *
+ * The Agent API request surface remains OpenAI-compatible: the returned array
+ * is intended for the normal CreateResponseRequest.tools field.
+ */
+async function resolvePresetTools(client, options) {
+    const presets = options.presets ?? (await client.presets.list()).data;
+    const toolCatalog = options.toolCatalog ?? (await client.tools.list()).data;
+    return resolvePresetToolsFromCatalog({ ...options, presets, toolCatalog });
+}
+function resolvePresetToolsFromCatalog(options) {
+    const presetId = options.preset.trim();
+    if (!presetId) {
+        throw new Error("preset is required");
+    }
+    const preset = options.presets?.find((row) => row.preset === presetId);
+    if (!preset) {
+        throw new Error(`preset not found: ${presetId}`);
+    }
+    const catalogByName = new Map();
+    for (const tool of options.toolCatalog ?? []) {
+        const name = tool.name?.trim();
+        if (name)
+            catalogByName.set(name, tool);
+    }
+    const missingToolNames = [];
+    const presetTools = [];
+    const unknownPresetTool = options.unknownPresetTool ?? "stub";
+    for (const name of preset.policy?.allowed_tools ?? []) {
+        const trimmed = name.trim();
+        if (!trimmed)
+            continue;
+        const catalogTool = catalogByName.get(trimmed);
+        if (catalogTool) {
+            presetTools.push(publicToolToRequestTool(catalogTool));
+            continue;
+        }
+        missingToolNames.push(trimmed);
+        if (unknownPresetTool === "error") {
+            throw new Error(`preset tool not found in catalog: ${trimmed}`);
+        }
+        if (unknownPresetTool === "stub") {
+            presetTools.push({ name: trimmed });
+        }
+    }
+    return {
+        preset,
+        tools: mergeTools(presetTools, options.tools ?? []),
+        missingToolNames,
+    };
+}
+function mergeTools(...groups) {
+    const out = [];
+    for (const group of groups) {
+        for (const tool of group) {
+            const name = tool.name?.trim();
+            if (!name) {
+                throw new Error("tools[].name is required");
+            }
+            out.push({ ...tool, name });
+        }
+    }
+    (0, tool_validation_js_1.validateUniqueToolNames)(out);
+    return out;
+}
+function publicToolToRequestTool(tool) {
+    const out = { name: tool.name };
+    if (tool.type)
+        out.type = tool.type;
+    if (tool.description)
+        out.description = tool.description;
+    if (tool.parameters)
+        out.parameters = tool.parameters;
+    if (tool.max_tokens != null)
+        out.max_tokens = tool.max_tokens;
+    if (tool.max_tokens_per_page != null)
+        out.max_tokens_per_page = tool.max_tokens_per_page;
+    if (tool.version)
+        out.version = tool.version;
+    return out;
+}

package/dist-cjs/resources/auth.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceAuthFlowError = exports.AuthResource = void 0;
+exports.browserAuthSessionExpiresWithin = browserAuthSessionExpiresWithin;
+const defaultDevicePollIntervalSeconds = 5;
+class AuthResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    startDeviceAuth(params = {}, options = {}) {
+        return this.http.request("POST", "/v1/auth/device/start", params, options);
+    }
+    pollDeviceAuth(params, options = {}) {
+        requireDeviceCode(params.device_code);
+        return this.http.request("POST", "/v1/auth/device/poll", params, options);
+    }
+    refreshBrowserSession(params, options = {}) {
+        requireRefreshToken(params.refresh_token);
+        return this.http.request("POST", "/v1/auth/refresh", {}, {
+            ...options,
+            headers: {
+                ...options.headers,
+                Cookie: `agent_api_refresh=${encodeURIComponent(params.refresh_token)}`,
+            },
+        });
+    }
+    async waitForDeviceAuth(params, options = {}) {
+        requireDeviceCode(params.device_code);
+        const startedAt = Date.now();
+        for (;;) {
+            throwIfAborted(params.signal);
+            const result = await this.pollDeviceAuth({ device_code: params.device_code }, options);
+            params.on_poll?.(result);
+            if (result.status === "approved" && result.access_token && result.refresh_token) {
+                return result;
+            }
+            if (result.status === "expired" || result.status === "consumed") {
+                throw new DeviceAuthFlowError(result.message || `Device auth ${result.status}`, result);
+            }
+            const timeoutMs = effectiveTimeoutMs(params, result);
+            if (timeoutMs !== undefined && Date.now() - startedAt >= timeoutMs) {
+                throw new DeviceAuthFlowError("Device auth timed out", result);
+            }
+            await sleep(pollDelayMs(params, result), params.signal);
+        }
+    }
+}
+exports.AuthResource = AuthResource;
+function browserAuthSessionExpiresWithin(session, windowMs = 60_000, nowMs = Date.now()) {
+    return session.access_token_expires_at * 1000 - nowMs <= windowMs;
+}
+class DeviceAuthFlowError extends Error {
+    result;
+    constructor(message, result) {
+        super(message);
+        this.name = "DeviceAuthFlowError";
+        this.result = result;
+        Object.setPrototypeOf(this, DeviceAuthFlowError.prototype);
+    }
+}
+exports.DeviceAuthFlowError = DeviceAuthFlowError;
+function requireDeviceCode(deviceCode) {
+    if (!deviceCode || !deviceCode.trim()) {
+        throw new TypeError("device_code is required");
+    }
+}
+function requireRefreshToken(refreshToken) {
+    if (!refreshToken || !refreshToken.trim()) {
+        throw new TypeError("refresh_token is required");
+    }
+}
+function pollDelayMs(params, result) {
+    const seconds = params.interval_seconds ?? result.interval_seconds ?? defaultDevicePollIntervalSeconds;
+    return Math.max(1, seconds) * 1000;
+}
+function effectiveTimeoutMs(params, result) {
+    if (params.timeout_ms !== undefined) {
+        return Math.max(0, params.timeout_ms);
+    }
+    const expiresAt = result.expires_at;
+    if (!expiresAt)
+        return undefined;
+    return Math.max(0, expiresAt * 1000 - Date.now());
+}
+function sleep(ms, signal) {
+    if (!signal) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(cleanupResolve, ms);
+        signal.addEventListener("abort", cleanupReject, { once: true });
+        function cleanupResolve() {
+            signal?.removeEventListener("abort", cleanupReject);
+            resolve();
+        }
+        function cleanupReject() {
+            clearTimeout(timeout);
+            reject(abortError());
+        }
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw abortError();
+    }
+}
+function abortError() {
+    return new DOMException("Device auth wait aborted", "AbortError");
+}

package/dist-cjs/resources/models.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelsResource = void 0;
+class ModelsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.request("GET", "/v1/models", undefined, options);
+    }
+}
+exports.ModelsResource = ModelsResource;

package/dist-cjs/resources/presets.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresetsResource = void 0;
+class PresetsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.request("GET", "/v1/presets", undefined, options);
+    }
+}
+exports.PresetsResource = PresetsResource;