@agent-api/sdk 1.1.3 → 1.1.4

package/dist-cjs/errors.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = exports.RateLimitError = exports.BadRequestError = exports.NotFoundError = exports.PermissionDeniedError = exports.AuthenticationError = exports.APIStatusError = exports.APIConnectionError = exports.APIError = void 0;
+exports.requestIDFromHeaders = requestIDFromHeaders;
+exports.retryAfterMsFromHeaders = retryAfterMsFromHeaders;
+exports.parseResponseError = parseResponseError;
+exports.isRetryableStatus = isRetryableStatus;
+class APIError extends Error {
+    status;
+    headers;
+    body;
+    code;
+    errorType;
+    requestID;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "APIError";
+        this.status = options.status;
+        this.headers = options.headers;
+        this.body = options.body;
+        this.code = options.code;
+        this.errorType = options.errorType;
+        this.requestID = options.requestID;
+    }
+}
+exports.APIError = APIError;
+class APIConnectionError extends APIError {
+    constructor(message, cause) {
+        super(message, { body: cause });
+        this.name = "APIConnectionError";
+    }
+}
+exports.APIConnectionError = APIConnectionError;
+class APIStatusError extends APIError {
+    status;
+    constructor(message, status, headers, body, options = {}) {
+        super(message, { status, headers, body, ...options });
+        this.name = "APIStatusError";
+        this.status = status;
+    }
+}
+exports.APIStatusError = APIStatusError;
+class AuthenticationError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class PermissionDeniedError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "PermissionDeniedError";
+    }
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+class NotFoundError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+class BadRequestError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "BadRequestError";
+    }
+}
+exports.BadRequestError = BadRequestError;
+class RateLimitError extends APIStatusError {
+    retryAfterMs;
+    constructor(message, status, headers, body, retryAfterMs, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "RateLimitError";
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.RateLimitError = RateLimitError;
+class InternalServerError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "InternalServerError";
+    }
+}
+exports.InternalServerError = InternalServerError;
+function requestIDFromHeaders(headers) {
+    return headers.get("x-request-id") ?? headers.get("request-id") ?? undefined;
+}
+function retryAfterMsFromHeaders(headers) {
+    const raw = headers.get("retry-after");
+    if (!raw) {
+        return undefined;
+    }
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(raw);
+    if (Number.isFinite(date)) {
+        return Math.max(0, date - Date.now());
+    }
+    return undefined;
+}
+function errorFields(body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (err && typeof err.message === "string") {
+            return { message: err.message, code: err.code, errorType: err.type };
+        }
+    }
+    return { message: "" };
+}
+async function parseResponseError(response) {
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        body = await response.text().catch(() => "");
+    }
+    const { message, code, errorType } = errorFields(body);
+    const requestID = requestIDFromHeaders(response.headers);
+    const finalMessage = message || `API request failed with status ${response.status}`;
+    const common = { code, errorType, requestID };
+    switch (response.status) {
+        case 400:
+            return new BadRequestError(finalMessage, response.status, response.headers, body, common);
+        case 401:
+            return new AuthenticationError(finalMessage, response.status, response.headers, body, common);
+        case 403:
+            return new PermissionDeniedError(finalMessage, response.status, response.headers, body, common);
+        case 404:
+            return new NotFoundError(finalMessage, response.status, response.headers, body, common);
+        case 429:
+            return new RateLimitError(finalMessage, response.status, response.headers, body, retryAfterMsFromHeaders(response.headers), common);
+        default:
+            if (response.status >= 500) {
+                return new InternalServerError(finalMessage, response.status, response.headers, body, common);
+            }
+            return new APIStatusError(finalMessage, response.status, response.headers, body, common);
+    }
+}
+function isRetryableStatus(status) {
+    return status === 408 || status === 409 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}

package/dist-cjs/index.js

@@ -0,0 +1,51 @@
+"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.DeviceAuthFlowError = exports.AuthResource = exports.resolvePresetToolsFromCatalog = exports.resolvePresetTools = exports.publicToolToRequestTool = exports.mergeTools = exports.runLocalFunctionHandlers = exports.pendingFunctionCalls = exports.functionCallOutputInput = exports.parseResponseError = exports.isRetryableStatus = exports.RateLimitError = exports.PermissionDeniedError = exports.NotFoundError = exports.InternalServerError = exports.BadRequestError = exports.AuthenticationError = exports.APIStatusError = exports.APIConnectionError = exports.APIError = exports.collectPage = exports.Page = exports.VERSION = exports.DEFAULT_TIMEOUT_MS = exports.DEFAULT_STREAM_TIMEOUT_MS = exports.DEFAULT_MAX_RETRIES = exports.AgentAPI = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "AgentAPI", { enumerable: true, get: function () { return client_js_1.AgentAPI; } });
+Object.defineProperty(exports, "DEFAULT_MAX_RETRIES", { enumerable: true, get: function () { return client_js_1.DEFAULT_MAX_RETRIES; } });
+Object.defineProperty(exports, "DEFAULT_STREAM_TIMEOUT_MS", { enumerable: true, get: function () { return client_js_1.DEFAULT_STREAM_TIMEOUT_MS; } });
+Object.defineProperty(exports, "DEFAULT_TIMEOUT_MS", { enumerable: true, get: function () { return client_js_1.DEFAULT_TIMEOUT_MS; } });
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return client_js_1.VERSION; } });
+var pagination_js_1 = require("./pagination.js");
+Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return pagination_js_1.Page; } });
+Object.defineProperty(exports, "collectPage", { enumerable: true, get: function () { return pagination_js_1.collectPage; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "APIError", { enumerable: true, get: function () { return errors_js_1.APIError; } });
+Object.defineProperty(exports, "APIConnectionError", { enumerable: true, get: function () { return errors_js_1.APIConnectionError; } });
+Object.defineProperty(exports, "APIStatusError", { enumerable: true, get: function () { return errors_js_1.APIStatusError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_js_1.AuthenticationError; } });
+Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return errors_js_1.BadRequestError; } });
+Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return errors_js_1.InternalServerError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_js_1.NotFoundError; } });
+Object.defineProperty(exports, "PermissionDeniedError", { enumerable: true, get: function () { return errors_js_1.PermissionDeniedError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_js_1.RateLimitError; } });
+Object.defineProperty(exports, "isRetryableStatus", { enumerable: true, get: function () { return errors_js_1.isRetryableStatus; } });
+Object.defineProperty(exports, "parseResponseError", { enumerable: true, get: function () { return errors_js_1.parseResponseError; } });
+__exportStar(require("./types/index.js"), exports);
+var local_functions_js_1 = require("./local-functions.js");
+Object.defineProperty(exports, "functionCallOutputInput", { enumerable: true, get: function () { return local_functions_js_1.functionCallOutputInput; } });
+Object.defineProperty(exports, "pendingFunctionCalls", { enumerable: true, get: function () { return local_functions_js_1.pendingFunctionCalls; } });
+Object.defineProperty(exports, "runLocalFunctionHandlers", { enumerable: true, get: function () { return local_functions_js_1.runLocalFunctionHandlers; } });
+var preset_tools_js_1 = require("./preset-tools.js");
+Object.defineProperty(exports, "mergeTools", { enumerable: true, get: function () { return preset_tools_js_1.mergeTools; } });
+Object.defineProperty(exports, "publicToolToRequestTool", { enumerable: true, get: function () { return preset_tools_js_1.publicToolToRequestTool; } });
+Object.defineProperty(exports, "resolvePresetTools", { enumerable: true, get: function () { return preset_tools_js_1.resolvePresetTools; } });
+Object.defineProperty(exports, "resolvePresetToolsFromCatalog", { enumerable: true, get: function () { return preset_tools_js_1.resolvePresetToolsFromCatalog; } });
+var auth_js_1 = require("./resources/auth.js");
+Object.defineProperty(exports, "AuthResource", { enumerable: true, get: function () { return auth_js_1.AuthResource; } });
+Object.defineProperty(exports, "DeviceAuthFlowError", { enumerable: true, get: function () { return auth_js_1.DeviceAuthFlowError; } });

package/dist-cjs/internal/env.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnv = readEnv;
+function readEnv(name) {
+    const env = globalThis.process?.env;
+    return env?.[name];
+}

package/dist-cjs/internal/http.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPClient = void 0;
+const errors_js_1 = require("../errors.js");
+const streaming_js_1 = require("../streaming.js");
+const version_js_1 = require("../version.js");
+class HTTPClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async request(method, path, body, options = {}) {
+        const response = await this.fetchWithRetry(method, path, body, options, false, false);
+        return (await response.json());
+    }
+    async requestRaw(method, path, body, options = {}) {
+        const response = await this.fetchWithRetry(method, path, body, options, false, true);
+        return (await response.json());
+    }
+    async requestVoid(method, path, options = {}) {
+        await this.fetchWithRetry(method, path, undefined, options, false, false);
+    }
+    async requestBinary(method, path, options = {}) {
+        const response = await this.fetchWithRetry(method, path, undefined, options, false, false);
+        return { body: await response.arrayBuffer(), headers: response.headers };
+    }
+    async stream(path, body, options = {}) {
+        const response = await this.fetchWithRetry("POST", path, body, options, true, false);
+        return (0, streaming_js_1.parseSSE)(response);
+    }
+    async fetchWithRetry(method, path, body, options, stream, rawBody) {
+        const maxRetries = options.maxRetries ?? this.options.maxRetries;
+        let attempt = 0;
+        for (;;) {
+            try {
+                return await this.fetchOnce(method, path, body, options, stream, rawBody);
+            }
+            catch (error) {
+                if (!(error instanceof errors_js_1.APIError) || attempt >= maxRetries) {
+                    throw error;
+                }
+                const retryable = error instanceof errors_js_1.APIConnectionError ||
+                    (error.status !== undefined && (0, errors_js_1.isRetryableStatus)(error.status));
+                if (!retryable) {
+                    throw error;
+                }
+                attempt += 1;
+                const delayMs = retryDelayMs(error, attempt);
+                await sleep(delayMs);
+            }
+        }
+    }
+    async fetchOnce(method, path, body, options, stream, rawBody) {
+        const controller = new AbortController();
+        const timeout = options.timeout ?? (stream ? this.options.streamTimeout : this.options.timeout);
+        const timeoutID = setTimeout(() => controller.abort(), timeout);
+        try {
+            const headers = {
+                Accept: stream ? "text/event-stream" : "application/json",
+                "User-Agent": version_js_1.USER_AGENT,
+                ...this.options.defaultHeaders,
+                ...options.headers,
+            };
+            if (body !== undefined && !rawBody) {
+                headers["Content-Type"] = "application/json";
+            }
+            if (this.options.apiKey) {
+                headers.Authorization = `Bearer ${this.options.apiKey}`;
+            }
+            const response = await this.options.fetchImpl(`${this.options.baseURL}${path}`, {
+                method,
+                headers,
+                body: body === undefined ? undefined : rawBody ? body : JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw await (0, errors_js_1.parseResponseError)(response);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.APIError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new errors_js_1.APIConnectionError(`Request timed out after ${timeout}ms`, error);
+            }
+            throw new errors_js_1.APIConnectionError("Request failed", error);
+        }
+        finally {
+            clearTimeout(timeoutID);
+        }
+    }
+}
+exports.HTTPClient = HTTPClient;
+function retryDelayMs(error, attempt) {
+    if (error instanceof errors_js_1.RateLimitError && error.retryAfterMs !== undefined) {
+        return error.retryAfterMs;
+    }
+    const base = 250;
+    const cap = 8000;
+    const exponential = Math.min(cap, base * 2 ** (attempt - 1));
+    const jitter = Math.floor(Math.random() * 100);
+    return exponential + jitter;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist-cjs/internal/output-text.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOutputText = addOutputText;
+function addOutputText(response) {
+    if (response.output_text !== undefined) {
+        return response;
+    }
+    response.output_text = response.output
+        .filter((item) => item.type === "message")
+        .flatMap((item) => item.content)
+        .filter((part) => part.type === "output_text")
+        .map((part) => part.text ?? "")
+        .join("");
+    return response;
+}

package/dist-cjs/internal/query.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQuery = buildQuery;
+function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== "") {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}

package/dist-cjs/local/context.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalContextPackage = createLocalContextPackage;
+exports.summarizeLocalContextSensitivity = summarizeLocalContextSensitivity;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const core_js_1 = require("./core.js");
+async function createLocalContextPackage(workspace, params = {}) {
+    const basePath = params.path ?? ".";
+    const maxFiles = positiveInt(params.maxFiles, 80);
+    const maxBytes = positiveInt(params.maxBytes, 256 * 1024);
+    const maxBytesPerFile = positiveInt(params.maxBytesPerFile, 32 * 1024);
+    const previewBytes = positiveInt(params.previewBytes, maxBytesPerFile);
+    const includeContent = params.includeContent ?? true;
+    const includeHashes = params.includeHashes ?? true;
+    const includeSummary = params.includeSummary ?? true;
+    const includeSearch = Boolean(params.includeSearch && params.query?.trim());
+    const includeSecrets = params.includeSecrets ?? false;
+    const stats = await workspace.list(basePath, { recursive: true });
+    const fileStats = stats
+        .filter((item) => item.type === "file")
+        .filter((item) => matchesPathFilters(item.path, params.include, params.exclude))
+        .sort((a, b) => a.path.localeCompare(b.path));
+    const files = [];
+    let includedBytes = 0;
+    let truncated = fileStats.length > maxFiles;
+    for (const item of fileStats.slice(0, maxFiles)) {
+        const sensitivity = (0, core_js_1.classifyLocalPathSensitivity)(item.path);
+        const baseFile = {
+            path: item.path,
+            size: item.size,
+            sensitivity: sensitivity.sensitivity,
+            sensitivity_reason: sensitivity.reason,
+        };
+        if (!includeSecrets && sensitivity.sensitivity === "secret") {
+            files.push({ ...baseFile, omitted_reason: "secret_path" });
+            continue;
+        }
+        if (item.size > maxBytesPerFile) {
+            files.push({ ...baseFile, omitted_reason: "file_too_large" });
+            truncated = true;
+            continue;
+        }
+        if (includedBytes >= maxBytes) {
+            files.push({ ...baseFile, omitted_reason: "package_budget_exceeded" });
+            truncated = true;
+            continue;
+        }
+        const remaining = maxBytes - includedBytes;
+        const readBudget = Math.min(previewBytes, maxBytesPerFile, remaining);
+        if (readBudget <= 0) {
+            files.push({ ...baseFile, omitted_reason: "package_budget_exceeded" });
+            truncated = true;
+            continue;
+        }
+        const delivered = await workspace.readFile(item.path, { maxBytes: readBudget });
+        includedBytes += delivered.encoding === "text"
+            ? Buffer.byteLength(delivered.content ?? "", "utf8")
+            : Buffer.byteLength(delivered.content_base64 ?? "", "base64");
+        const packaged = {
+            ...baseFile,
+            mime_type: delivered.mime_type,
+            encoding: delivered.encoding,
+            truncated: delivered.truncated || undefined,
+        };
+        if (includeContent) {
+            packaged.content = delivered.content;
+            packaged.content_base64 = delivered.content_base64;
+        }
+        if (includeHashes) {
+            packaged.sha256 = await sha256File(workspace, item.path);
+        }
+        if (delivered.truncated) {
+            truncated = true;
+        }
+        files.push(packaged);
+    }
+    const summary = includeSummary
+        ? await workspace.summarize({
+            path: basePath,
+            maxFiles,
+            previewBytes,
+            ignore: params.exclude,
+        })
+        : undefined;
+    const search = includeSearch
+        ? await workspace.grep({
+            pattern: params.query,
+            path: basePath,
+            limit: maxFiles,
+            maxBytesPerFile,
+            ignore: params.exclude,
+        })
+        : undefined;
+    return {
+        object: "local_context_manifest",
+        root: workspace.root,
+        workspace_name: workspace.name,
+        generated_at_unix: Math.floor(Date.now() / 1000),
+        base_path: basePath,
+        file_count: fileStats.length,
+        total_bytes: fileStats.reduce((sum, item) => sum + item.size, 0),
+        included_bytes: includedBytes,
+        truncated,
+        files,
+        summary,
+        search,
+    };
+}
+function summarizeLocalContextSensitivity(files) {
+    const order = { normal: 0, sensitive: 1, secret: 2 };
+    let highest = "normal";
+    const sensitiveFiles = [];
+    for (const file of files) {
+        if (order[file.sensitivity] > order[highest]) {
+            highest = file.sensitivity;
+        }
+        if (file.sensitivity !== "normal") {
+            sensitiveFiles.push({
+                path: file.path,
+                sensitivity: file.sensitivity,
+                reason: file.sensitivity_reason,
+            });
+        }
+    }
+    return { highest, files: sensitiveFiles };
+}
+function matchesPathFilters(relativePath, include, exclude) {
+    if (include?.length && !include.some((pattern) => pathMatches(relativePath, pattern))) {
+        return false;
+    }
+    if (exclude?.some((pattern) => pathMatches(relativePath, pattern))) {
+        return false;
+    }
+    return true;
+}
+function pathMatches(relativePath, pattern) {
+    const clean = pattern.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!clean || clean === ".") {
+        return true;
+    }
+    if (!clean.includes("*")) {
+        return relativePath === clean || relativePath.startsWith(`${clean}/`);
+    }
+    const escaped = clean
+        .split("*")
+        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+        .join(".*");
+    return new RegExp(`^${escaped}$`).test(relativePath);
+}
+function positiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : fallback;
+}
+async function sha256File(workspace, relativePath) {
+    const fullPath = workspace.files.resolvePath(relativePath);
+    return (0, node_crypto_1.createHash)("sha256").update(await (0, promises_1.readFile)(fullPath)).digest("hex");
+}