@puku-ai/sdk 4.0.3 → 4.0.4

package/dist/vendor/core/api-promise.cjs

@@ -0,0 +1,80 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIPromise = void 0;
+const parse_1 = require("../internal/parse");
+/**
+ * A subclass of `Promise` providing additional helper methods
+ * for interacting with the SDK.
+ */
+class APIPromise extends Promise {
+    responsePromise;
+    parseResponse;
+    parsedPromise;
+    #client;
+    constructor(client, responsePromise, parseResponse = parse_1.defaultParseResponse) {
+        super((resolve) => {
+            // this is maybe a bit weird but this has to be a no-op to not implicitly
+            // parse the response body; instead .then, .catch, .finally are overridden
+            // to parse the response
+            resolve(null);
+        });
+        this.responsePromise = responsePromise;
+        this.parseResponse = parseResponse;
+        this.#client = client;
+    }
+    _thenUnwrap(transform) {
+        return new APIPromise(this.#client, this.responsePromise, async (client, props) => (0, parse_1.addResponseIDs)(transform(await this.parseResponse(client, props), props), props.response));
+    }
+    /**
+     * Gets the raw `Response` instance instead of parsing the response
+     * data.
+     *
+     * If you want to parse the response body but still get the `Response`
+     * instance, you can use {@link withResponse()}.
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+     * to your `tsconfig.json`.
+     */
+    asResponse() {
+        return this.responsePromise.then((p) => p.response);
+    }
+    /**
+     * Gets the parsed response data, the raw `Response` instance and the ID of the request,
+     * returned via the `request-id` header which is useful for debugging requests and resporting
+     * issues to PukuAI.
+     *
+     * If you just want to get the raw `Response` instance without parsing it,
+     * you can use {@link asResponse()}.
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+     * to your `tsconfig.json`.
+     */
+    async withResponse() {
+        const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+        return {
+            data,
+            response,
+            request_id: response.headers.get('request-id'),
+            workspace_id: response.headers.get('puku-workspace-id'),
+        };
+    }
+    parse() {
+        if (!this.parsedPromise) {
+            this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(this.#client, data));
+        }
+        return this.parsedPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.parse().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.parse().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.parse().finally(onfinally);
+    }
+}
+exports.APIPromise = APIPromise;

package/dist/vendor/core/api.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vendor/core/credentials.cjs

@@ -0,0 +1,313 @@
+"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.getCredentialsPath = exports.loadCredentials = exports.loadConfigWithSource = exports.loadConfig = exports.CREDENTIALS_FILE_VERSION = exports.CONFIG_FILE_VERSION = void 0;
+const detect_platform_1 = require("../internal/detect-platform");
+const utils_1 = require("../internal/utils");
+/** Current schema version written to `configs/<profile>.json`. Absent on read ⇒ "1.0". */
+exports.CONFIG_FILE_VERSION = '1.0';
+/** Current schema version written to `credentials/<profile>.json`. Absent on read ⇒ "1.0". */
+exports.CREDENTIALS_FILE_VERSION = '1.0';
+const PROFILE_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
+function validateProfileName(name) {
+    if (!name) {
+        throw new Error('profile name is empty');
+    }
+    if (name === '.' || name === '..') {
+        throw new Error(`profile name "${name}" is not allowed`);
+    }
+    if (name.includes('/') || name.includes('\\')) {
+        throw new Error(`profile name "${name}" must not contain path separators`);
+    }
+    if (!PROFILE_NAME_PATTERN.test(name)) {
+        throw new Error(`profile name "${name}" contains disallowed characters (allowed: letters, digits, '_', '.', '-')`);
+    }
+}
+/**
+ * Loads the PukuAI configuration for the given (or active) profile.
+ *
+ * Returns `null` when running in a browser or no configuration can be resolved.
+ * Otherwise, returns the configuration based on the config file and environment variables.
+ *
+ * **Profile resolution** (first match wins):
+ *   1. Explicit `profile` argument
+ *   2. `PUKU_PROFILE` environment variable
+ *   3. Contents of `<config_dir>/active_config` file
+ *   4. `"default"`
+ *
+ * **Config resolution:**
+ *   - If `<config_dir>/configs/<profile>.json` exists, it is loaded and
+ *     missing fields are filled from environment variables. Values present
+ *     in the file take precedence — env vars only fill gaps:
+ *       - `PUKU_BASE_URL` → `base_url`
+ *       - `PUKU_ORGANIZATION_ID` → `organization_id`
+ *       - `PUKU_WORKSPACE_ID` → `workspace_id`
+ *       - `PUKU_SCOPE` → `authentication.scope`
+ *       - `PUKU_FEDERATION_RULE_ID` → `authentication.federation_rule_id` (oidc_federation)
+ *       - `PUKU_IDENTITY_TOKEN_FILE` → `authentication.identity_token` (oidc_federation)
+ *       - `PUKU_SERVICE_ACCOUNT_ID` → `authentication.service_account_id` (oidc_federation)
+ *   - If no config file exists, an `oidc_federation` config is synthesized
+ *     entirely from environment variables when both `PUKU_FEDERATION_RULE_ID`
+ *     and `PUKU_ORGANIZATION_ID` are set.
+ */
+const loadConfig = async (profile) => {
+    return (await (0, exports.loadConfigWithSource)(profile))?.config ?? null;
+};
+exports.loadConfig = loadConfig;
+/**
+ * Same as {@link loadConfig}, but also reports whether the config was loaded
+ * from a profile file on disk (`fromFile: true`) or synthesized entirely from
+ * environment variables (`fromFile: false`).
+ */
+const loadConfigWithSource = async (profile) => {
+    const rootConfigPath = await getRootConfigPath();
+    if (rootConfigPath === null) {
+        return null;
+    }
+    const profileName = profile ?? (await getActiveProfileName());
+    if (profileName === null) {
+        return null;
+    }
+    validateProfileName(profileName);
+    const { fs, path } = await Promise.resolve().then(() => __importStar(require('../internal/node')));
+    const configPath = path.join(rootConfigPath, 'configs', `${profileName}.json`);
+    let configRaw;
+    try {
+        configRaw = await fs.promises.readFile(configPath, 'utf-8');
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            throw new Error(`failed to read config file ${configPath}: ${err}`);
+        }
+        configRaw = null;
+    }
+    if (configRaw === null) {
+        const organizationId = (0, utils_1.readEnv)('PUKU_ORGANIZATION_ID');
+        const identityTokenFile = (0, utils_1.readEnv)('PUKU_IDENTITY_TOKEN_FILE');
+        const federationRuleId = (0, utils_1.readEnv)('PUKU_FEDERATION_RULE_ID');
+        if (federationRuleId && organizationId) {
+            return {
+                fromFile: false,
+                config: {
+                    organization_id: organizationId,
+                    // A defaulted-but-empty CI variable (`PUKU_WORKSPACE_ID=""`) is
+                    // treated as unset — readEnv coerces empty to undefined, and the body
+                    // builder's truthy check skips it — so `"workspace_id": ""` never goes
+                    // on the wire.
+                    workspace_id: (0, utils_1.readEnv)('PUKU_WORKSPACE_ID'),
+                    base_url: (0, utils_1.readEnv)('PUKU_BASE_URL'),
+                    authentication: {
+                        type: 'oidc_federation',
+                        federation_rule_id: federationRuleId,
+                        service_account_id: (0, utils_1.readEnv)('PUKU_SERVICE_ACCOUNT_ID'),
+                        identity_token: identityTokenFile ? { source: 'file', path: identityTokenFile } : undefined,
+                        scope: (0, utils_1.readEnv)('PUKU_SCOPE'),
+                    },
+                },
+            };
+        }
+        return null;
+    }
+    let config;
+    try {
+        config = JSON.parse(configRaw);
+    }
+    catch (err) {
+        throw new Error(`failed to parse config file ${configPath}: ${err}`);
+    }
+    if (!config.authentication) {
+        throw new Error(`config file ${configPath} is missing "authentication"`);
+    }
+    const authType = config.authentication.type;
+    if (authType !== 'oidc_federation' && authType !== 'user_oauth') {
+        throw new Error(`authentication.type "${authType}" is not a known authentication type`);
+    }
+    // File values are authoritative; env vars only fill fields the file left unset.
+    config.organization_id ??= (0, utils_1.readEnv)('PUKU_ORGANIZATION_ID');
+    config.workspace_id ??= (0, utils_1.readEnv)('PUKU_WORKSPACE_ID');
+    config.base_url ??= (0, utils_1.readEnv)('PUKU_BASE_URL');
+    config.authentication.scope ??= (0, utils_1.readEnv)('PUKU_SCOPE');
+    if (config.authentication.type === 'oidc_federation') {
+        if (!config.authentication.identity_token) {
+            const identityTokenFile = (0, utils_1.readEnv)('PUKU_IDENTITY_TOKEN_FILE');
+            if (identityTokenFile) {
+                config.authentication.identity_token = {
+                    source: 'file',
+                    path: identityTokenFile,
+                };
+            }
+        }
+        // Unlike siblings using `??= readEnv()` (which leaves `undefined`), coerce
+        // to '' so the type stays `string` (always set). The downstream required
+        // check in credential-chain rejects empty, so semantics match but types are
+        // cleaner.
+        if (!config.authentication.federation_rule_id) {
+            config.authentication.federation_rule_id = (0, utils_1.readEnv)('PUKU_FEDERATION_RULE_ID') ?? '';
+        }
+        config.authentication.service_account_id ??= (0, utils_1.readEnv)('PUKU_SERVICE_ACCOUNT_ID');
+    }
+    return { config, fromFile: true };
+};
+exports.loadConfigWithSource = loadConfigWithSource;
+/**
+ * Loads the credential material for the active profile.
+ *
+ * Returns the parsed credentials or `null` when running in a browser or
+ * no credentials file can be found.
+ *
+ * **Profile resolution** (first match wins):
+ *   1. `PUKU_PROFILE` environment variable
+ *   2. Contents of `<config_dir>/active_config` file
+ *   3. `"default"`
+ *
+ * **Credentials path resolution** (first match wins):
+ *   1. `authentication.credentials_path` from the active profile's config (via {@link loadConfig})
+ *   2. `<config_dir>/credentials/<profile>.json`
+ */
+const loadCredentials = async () => {
+    const config = await (0, exports.loadConfig)();
+    const credentialsPath = await (0, exports.getCredentialsPath)(config);
+    if (!credentialsPath) {
+        return null;
+    }
+    const { fs } = await Promise.resolve().then(() => __importStar(require('../internal/node')));
+    let raw;
+    try {
+        raw = await fs.promises.readFile(credentialsPath, 'utf-8');
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            throw new Error(`failed to read credentials file ${credentialsPath}: ${err}`);
+        }
+        return null;
+    }
+    let creds;
+    try {
+        creds = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`failed to parse credentials file ${credentialsPath}: ${err}`);
+    }
+    if (creds.type && creds.type !== 'oauth_token') {
+        throw new Error(`credentials file ${credentialsPath} has unsupported type "${creds.type}" (want "oauth_token")`);
+    }
+    return creds;
+};
+exports.loadCredentials = loadCredentials;
+/**
+ * Resolves the credentials file path for the given config.
+ *
+ * Uses `authentication.credentials_path` from the config if set, otherwise
+ * falls back to `<config_dir>/credentials/<profile>.json`.
+ *
+ * Returns `null` when running in a browser or the path cannot be resolved.
+ */
+const getCredentialsPath = async (config, profile) => {
+    if (config?.authentication.credentials_path) {
+        return config.authentication.credentials_path;
+    }
+    const rootConfigPath = await getRootConfigPath();
+    if (!rootConfigPath) {
+        return null;
+    }
+    const profileName = profile ?? (await getActiveProfileName());
+    if (!profileName) {
+        return null;
+    }
+    validateProfileName(profileName);
+    const { path } = await Promise.resolve().then(() => __importStar(require('../internal/node')));
+    return path.join(rootConfigPath, 'credentials', `${profileName}.json`);
+};
+exports.getCredentialsPath = getCredentialsPath;
+const getRootConfigPath = async () => {
+    if (!supportsLocalConfigFiles()) {
+        return null;
+    }
+    const { path } = await Promise.resolve().then(() => __importStar(require('../internal/node')));
+    // PUKU_CONFIG_DIR is treated as a trusted path: it is set by the
+    // process operator, not by remote input, so it is not validated.
+    const configDir = (0, utils_1.readEnv)('PUKU_CONFIG_DIR');
+    if (configDir) {
+        return configDir;
+    }
+    const os = (0, detect_platform_1.getPlatformHeaders)()['X-Stainless-OS'];
+    if (os === 'Windows') {
+        const appData = (0, utils_1.readEnv)('APPDATA');
+        if (appData) {
+            return path.join(appData, 'PukuAI');
+        }
+        const userProfile = (0, utils_1.readEnv)('USERPROFILE');
+        if (userProfile) {
+            return path.join(userProfile, 'AppData', 'Roaming', 'PukuAI');
+        }
+        // No usable Windows config root — return null so callers fall through to
+        // "no config available" rather than silently writing under C:\.
+        return null;
+    }
+    const xdgConfigHome = (0, utils_1.readEnv)('XDG_CONFIG_HOME');
+    if (xdgConfigHome) {
+        return path.join(xdgConfigHome, 'puku');
+    }
+    const home = (0, utils_1.readEnv)('HOME');
+    if (home) {
+        return path.join(home, '.config', 'puku');
+    }
+    return null;
+};
+const supportsLocalConfigFiles = () => {
+    const runtime = (0, detect_platform_1.getPlatformHeaders)()['X-Stainless-Runtime'];
+    return runtime === 'node' || runtime === 'deno';
+};
+const getActiveProfileName = async () => {
+    const rootConfigPath = await getRootConfigPath();
+    if (!rootConfigPath) {
+        return null;
+    }
+    const profileName = (0, utils_1.readEnv)('PUKU_PROFILE');
+    if (profileName) {
+        return profileName;
+    }
+    const { fs, path } = await Promise.resolve().then(() => __importStar(require('../internal/node')));
+    const filePath = path.join(rootConfigPath, 'active_config');
+    try {
+        return (await fs.promises.readFile(filePath, 'utf-8')).trim() || 'default';
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            throw new Error(`failed to read ${filePath}: ${err}`);
+        }
+        return 'default';
+    }
+};

package/dist/vendor/core/error.cjs

@@ -0,0 +1,156 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = exports.RateLimitError = exports.UnprocessableEntityError = exports.ConflictError = exports.NotFoundError = exports.PermissionDeniedError = exports.AuthenticationError = exports.BadRequestError = exports.RetryableError = exports.APIConnectionTimeoutError = exports.APIConnectionError = exports.APIUserAbortError = exports.APIError = exports.PukuError = void 0;
+const errors_1 = require("../internal/errors");
+/**
+ * Branded base error class for the Puku SDK. Every error the SDK throws
+ * is an instance of `PukuError`, so `err.toString()` and stack traces
+ * report `PukuError: …` consistently.
+ *
+ * `instanceof PukuError` is the canonical check. The class itself is
+ * re-exported from `@puku-ai/sdk` under both `PukuError` and the legacy
+ * `PukuError` name; both refer to the same constructor.
+ */
+class PukuError extends Error {
+    name = 'PukuError';
+    constructor(message) {
+        super(message);
+        this.name = 'PukuError';
+    }
+}
+exports.PukuError = PukuError;
+class APIError extends PukuError {
+    /** HTTP status for the response that caused the error */
+    status;
+    /** HTTP headers for the response that caused the error */
+    headers;
+    /** JSON body of the response that caused the error */
+    error;
+    requestID;
+    workspaceID;
+    /** The `error.type` from the API response body, e.g. `"rate_limit_error"` */
+    type;
+    constructor(status, error, message, headers, type) {
+        super(`${APIError.makeMessage(status, error, message)}`);
+        this.status = status;
+        this.headers = headers;
+        this.requestID = headers?.get('request-id');
+        this.workspaceID = headers?.get('puku-workspace-id');
+        this.error = error;
+        this.type = type ?? null;
+    }
+    static makeMessage(status, error, message) {
+        const msg = error?.message ?
+            typeof error.message === 'string' ?
+                error.message
+                : JSON.stringify(error.message)
+            : error ? JSON.stringify(error)
+                : message;
+        if (status && msg) {
+            return `${status} ${msg}`;
+        }
+        if (status) {
+            return `${status} status code (no body)`;
+        }
+        if (msg) {
+            return msg;
+        }
+        return '(no status code or body)';
+    }
+    static generate(status, errorResponse, message, headers) {
+        if (!status || !headers) {
+            return new APIConnectionError({ message, cause: (0, errors_1.castToError)(errorResponse) });
+        }
+        const error = errorResponse;
+        const type = error?.['error']?.['type'];
+        if (status === 400) {
+            return new BadRequestError(status, error, message, headers, type);
+        }
+        if (status === 401) {
+            return new AuthenticationError(status, error, message, headers, type);
+        }
+        if (status === 403) {
+            return new PermissionDeniedError(status, error, message, headers, type);
+        }
+        if (status === 404) {
+            return new NotFoundError(status, error, message, headers, type);
+        }
+        if (status === 409) {
+            return new ConflictError(status, error, message, headers, type);
+        }
+        if (status === 422) {
+            return new UnprocessableEntityError(status, error, message, headers, type);
+        }
+        if (status === 429) {
+            return new RateLimitError(status, error, message, headers, type);
+        }
+        if (status >= 500) {
+            return new InternalServerError(status, error, message, headers, type);
+        }
+        return new APIError(status, error, message, headers, type);
+    }
+}
+exports.APIError = APIError;
+class APIUserAbortError extends APIError {
+    constructor({ message } = {}) {
+        super(undefined, undefined, message || 'Request was aborted.', undefined);
+    }
+}
+exports.APIUserAbortError = APIUserAbortError;
+class APIConnectionError extends APIError {
+    constructor({ message, cause }) {
+        super(undefined, undefined, message || 'Connection error.', undefined);
+        // in some environments the 'cause' property is already declared
+        // @ts-ignore
+        if (cause)
+            this.cause = cause;
+    }
+}
+exports.APIConnectionError = APIConnectionError;
+class APIConnectionTimeoutError extends APIConnectionError {
+    constructor({ message } = {}) {
+        super({ message: message ?? 'Request timed out.' });
+    }
+}
+exports.APIConnectionTimeoutError = APIConnectionTimeoutError;
+/**
+ * An error that opts into the SDK's retry policy: throw it (e.g. from
+ * middleware) to have the attempt retried.
+ *
+ * Note that the request will only be retried when `maxRetries` has not been exhausted.
+ */
+class RetryableError extends PukuError {
+    constructor(message, { cause } = {}) {
+        super(message ?? 'Retryable error.');
+        // in some environments the 'cause' property is already declared
+        // @ts-ignore
+        if (cause !== undefined)
+            this.cause = cause;
+    }
+}
+exports.RetryableError = RetryableError;
+class BadRequestError extends APIError {
+}
+exports.BadRequestError = BadRequestError;
+class AuthenticationError extends APIError {
+}
+exports.AuthenticationError = AuthenticationError;
+class PermissionDeniedError extends APIError {
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+class NotFoundError extends APIError {
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends APIError {
+}
+exports.ConflictError = ConflictError;
+class UnprocessableEntityError extends APIError {
+}
+exports.UnprocessableEntityError = UnprocessableEntityError;
+class RateLimitError extends APIError {
+}
+exports.RateLimitError = RateLimitError;
+class InternalServerError extends APIError {
+}
+exports.InternalServerError = InternalServerError;