@puku-ai/sdk 4.0.3 → 4.0.4

package/dist/vendor/resources/messages/messages.cjs

@@ -0,0 +1,159 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+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.Messages = void 0;
+const resource_1 = require("../../core/resource");
+const headers_1 = require("../../internal/headers");
+const stainless_helper_header_1 = require("../../internal/stainless-helper-header");
+const MessageStream_1 = require("../../lib/MessageStream");
+const parser_1 = require("../../lib/parser");
+const BatchesAPI = __importStar(require("./batches"));
+const batches_1 = require("./batches");
+const constants_1 = require("../../internal/constants");
+class Messages extends resource_1.APIResource {
+    batches = new BatchesAPI.Batches(this._client);
+    create(params, options) {
+        const { user_profile_id, ...body } = params;
+        if (body.model in DEPRECATED_MODELS) {
+            console.warn(`The Puku SDK model '${body.model}' is deprecated and will reach end-of-life on ${DEPRECATED_MODELS[body.model]}\nPlease migrate to a newer model. Visit https://puku.ai/docs/resources/model-deprecations for more information.`);
+        }
+        if (MODELS_TO_WARN_WITH_THINKING_ENABLED.includes(body.model) &&
+            body.thinking &&
+            body.thinking.type === 'enabled') {
+            console.warn(`Using Puku with ${body.model} and 'thinking.type=enabled' is deprecated. Use 'thinking.type=adaptive' instead which results in better model performance in our testing: https://puku.ai/docs/en/build-with-puku/adaptive-thinking`);
+        }
+        let timeout = options?.timeout ?? this._client._options.timeout;
+        if (!body.stream && timeout == null) {
+            const maxNonstreamingTokens = constants_1.MODEL_NONSTREAMING_TOKENS[body.model] ?? undefined;
+            timeout = this._client.calculateNonstreamingTimeout(body.max_tokens, maxNonstreamingTokens);
+        }
+        // Collect helper info from tools and messages
+        const helperHeader = (0, stainless_helper_header_1.stainlessHelperHeader)(body.tools, body.messages);
+        return this._client.post('/v1/messages', {
+            body,
+            timeout: timeout ?? 600000,
+            ...options,
+            headers: (0, headers_1.buildHeaders)([
+                { ...(user_profile_id != null ? { 'puku-user-profile-id': user_profile_id } : undefined) },
+                helperHeader,
+                options?.headers,
+            ]),
+            stream: params.stream ?? false,
+        });
+    }
+    /**
+     * Send a structured list of input messages with text and/or image content, along with an expected `output_config.format` and
+     * the response will be automatically parsed and available in the `parsed_output` property of the message.
+     *
+     * @example
+     * ```ts
+     * const message = await client.messages.parse({
+     *   model: 'puku-ai-2.8',
+     *   max_tokens: 1024,
+     *   messages: [{ role: 'user', content: 'What is 2+2?' }],
+     *   output_config: {
+     *     format: zodOutputFormat(z.object({ answer: z.number() })),
+     *   },
+     * });
+     *
+     * console.log(message.parsed_output?.answer); // 4
+     * ```
+     */
+    parse(params, options) {
+        return this.create(params, options).then((message) => (0, parser_1.parseMessage)(message, params, { logger: this._client.logger ?? console }));
+    }
+    /**
+     * Create a Message stream.
+     *
+     * If `output_config.format` is provided with a parseable format (like `zodOutputFormat()`),
+     * the final message will include a `parsed_output` property with the parsed content.
+     *
+     * @example
+     * ```ts
+     * const stream = client.messages.stream({
+     *   model: 'puku-ai-2.8',
+     *   max_tokens: 1024,
+     *   messages: [{ role: 'user', content: 'What is 2+2?' }],
+     *   output_config: {
+     *     format: zodOutputFormat(z.object({ answer: z.number() })),
+     *   },
+     * });
+     *
+     * const message = await stream.finalMessage();
+     * console.log(message.parsed_output?.answer); // 4
+     * ```
+     */
+    stream(body, options) {
+        return MessageStream_1.MessageStream.createMessage(this, body, options, { logger: this._client.logger ?? console });
+    }
+    /**
+     * Count the number of tokens in a Message.
+     *
+     * The Token Count API can be used to count the number of tokens in a Message,
+     * including tools, images, and documents, without creating it.
+     *
+     * Learn more about token counting in our
+     * [user guide](https://platform.puku.com/docs/en/build-with-puku/token-counting)
+     *
+     * @example
+     * ```ts
+     * const messageTokensCount =
+     *   await client.messages.countTokens({
+     *     messages: [{ content: 'Hello, world', role: 'user' }],
+     *     model: 'puku-ai-2.8',
+     *   });
+     * ```
+     */
+    countTokens(params, options) {
+        const { user_profile_id, ...body } = params;
+        return this._client.post('/v1/messages/count_tokens', {
+            body,
+            ...options,
+            headers: (0, headers_1.buildHeaders)([
+                { ...(user_profile_id != null ? { 'puku-user-profile-id': user_profile_id } : undefined) },
+                options?.headers,
+            ]),
+        });
+    }
+}
+exports.Messages = Messages;
+const DEPRECATED_MODELS = {
+// Puku AI exposes `puku-ai-2.7`, `puku-ai-2.8`, and `opus-4.8`. None of
+// these are deprecated at this time — extend this map when (and only
+// when) a model is announced for retirement. Date format: 'Month Dth, YYYY'.
+};
+const MODELS_TO_WARN_WITH_THINKING_ENABLED = [];
+Messages.Batches = batches_1.Batches;

package/dist/vendor/resources/messages.cjs

@@ -0,0 +1,18 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+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 });
+__exportStar(require("./messages/index"), exports);

package/dist/vendor/resources/models.cjs

@@ -0,0 +1,44 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Models = void 0;
+const resource_1 = require("../core/resource");
+const pagination_1 = require("../core/pagination");
+const headers_1 = require("../internal/headers");
+const path_1 = require("../internal/utils/path");
+class Models extends resource_1.APIResource {
+    /**
+     * Get a specific model.
+     *
+     * The Models API response can be used to determine information about a specific
+     * model or resolve a model alias to a model ID.
+     */
+    retrieve(modelID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.get((0, path_1.path) `/v1/models/${modelID}`, {
+            ...options,
+            headers: (0, headers_1.buildHeaders)([
+                { ...(betas?.toString() != null ? { 'puku-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * List available models.
+     *
+     * The Models API response can be used to determine which models are available for
+     * use in the API. More recently released models are listed first.
+     */
+    list(params = {}, options) {
+        const { betas, ...query } = params ?? {};
+        return this._client.getAPIList('/v1/models', (pagination_1.Page), {
+            query,
+            ...options,
+            headers: (0, headers_1.buildHeaders)([
+                { ...(betas?.toString() != null ? { 'puku-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+        });
+    }
+}
+exports.Models = Models;

package/dist/vendor/resources/shared.cjs

@@ -0,0 +1,3 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vendor/resources/skills/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Versions = exports.Skills = void 0;
+var skills_1 = require("./skills");
+Object.defineProperty(exports, "Skills", { enumerable: true, get: function () { return skills_1.Skills; } });
+var versions_1 = require("./versions");
+Object.defineProperty(exports, "Versions", { enumerable: true, get: function () { return versions_1.Versions; } });

package/dist/vendor/resources/skills/skills.cjs

@@ -0,0 +1,72 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+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.Skills = void 0;
+const resource_1 = require("../../core/resource");
+const VersionsAPI = __importStar(require("./versions"));
+const versions_1 = require("./versions");
+const pagination_1 = require("../../core/pagination");
+const uploads_1 = require("../../internal/uploads");
+const path_1 = require("../../internal/utils/path");
+class Skills extends resource_1.APIResource {
+    versions = new VersionsAPI.Versions(this._client);
+    /**
+     * Create Skill
+     */
+    create(body, options) {
+        return this._client.post('/v1/skills', (0, uploads_1.multipartFormRequestOptions)({ body, ...options }, this._client, false));
+    }
+    /**
+     * Get Skill
+     */
+    retrieve(skillID, options) {
+        return this._client.get((0, path_1.path) `/v1/skills/${skillID}`, options);
+    }
+    /**
+     * List Skills
+     */
+    list(query = {}, options) {
+        return this._client.getAPIList('/v1/skills', (pagination_1.PageCursor), { query, ...options });
+    }
+    /**
+     * Delete Skill
+     */
+    delete(skillID, options) {
+        return this._client.delete((0, path_1.path) `/v1/skills/${skillID}`, options);
+    }
+}
+exports.Skills = Skills;
+Skills.Versions = versions_1.Versions;

package/dist/vendor/resources/skills/versions.cjs

@@ -0,0 +1,40 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Versions = void 0;
+const resource_1 = require("../../core/resource");
+const pagination_1 = require("../../core/pagination");
+const uploads_1 = require("../../internal/uploads");
+const path_1 = require("../../internal/utils/path");
+class Versions extends resource_1.APIResource {
+    /**
+     * Create Skill Version
+     */
+    create(skillID, body, options) {
+        return this._client.post((0, path_1.path) `/v1/skills/${skillID}/versions`, (0, uploads_1.multipartFormRequestOptions)({ body, ...options }, this._client, false));
+    }
+    /**
+     * Get Skill Version
+     */
+    retrieve(version, params, options) {
+        const { skill_id } = params;
+        return this._client.get((0, path_1.path) `/v1/skills/${skill_id}/versions/${version}`, options);
+    }
+    /**
+     * List Skill Versions
+     */
+    list(skillID, query = {}, options) {
+        return this._client.getAPIList((0, path_1.path) `/v1/skills/${skillID}/versions`, (pagination_1.PageCursor), {
+            query,
+            ...options,
+        });
+    }
+    /**
+     * Delete Skill Version
+     */
+    delete(version, params, options) {
+        const { skill_id } = params;
+        return this._client.delete((0, path_1.path) `/v1/skills/${skill_id}/versions/${version}`, options);
+    }
+}
+exports.Versions = Versions;

package/dist/vendor/resources/skills.cjs

@@ -0,0 +1,18 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+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 });
+__exportStar(require("./skills/index"), exports);

package/dist/vendor/resources/top-level.cjs

@@ -0,0 +1,3 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vendor/resources.cjs

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./resources/index"), exports);

package/dist/vendor/streaming.cjs

@@ -0,0 +1,18 @@
+"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 });
+/** @deprecated Import from ./core/streaming instead */
+__exportStar(require("./core/streaming"), exports);

package/dist/vendor/tools/agent-toolset/fs-util.cjs

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Shared, Node-only filesystem helpers for the agent toolset's file tools:
+ * path confinement (symlink-aware), an atomic write, and language-independent
+ * error messages. Kept out of `node.ts` so the tool implementations stay focused
+ * and these helpers can be reused by every file tool.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILE_CREATE_MODE = exports.DIR_CREATE_MODE = void 0;
+exports.isWithin = isWithin;
+exports.containingRoot = containingRoot;
+exports.errnoCode = errnoCode;
+exports.canonicalize = canonicalize;
+exports.confineToRoot = confineToRoot;
+exports.atomicWriteFile = atomicWriteFile;
+exports.fsErrorMessage = fsErrorMessage;
+const node_1 = require("../../internal/node");
+const ToolError_1 = require("../../lib/tools/ToolError");
+const fs = node_1.fs.promises;
+/** Mode for directories the file tools create — not world-writable under a 0 umask. */
+exports.DIR_CREATE_MODE = 0o755;
+/** Mode for files the file tools create. */
+exports.FILE_CREATE_MODE = 0o644;
+/** True when `p` is `root` itself or lexically contained within it. */
+function isWithin(root, p) {
+    const rel = node_1.path.relative(root, p);
+    return rel === '' || (!rel.startsWith('..' + node_1.path.sep) && rel !== '..' && !node_1.path.isAbsolute(rel));
+}
+/**
+ * The first entry of `roots` whose canonical form contains the
+ * already-canonical `target`, returned as configured; `undefined` when none
+ * does. Each root goes through {@link canonicalize} at check time, exactly like
+ * the workdir in {@link confineToRoot}, so granting access (`allowedRoots`)
+ * and refusing writes (`readOnlyRoots`) can never resolve the same entry two
+ * different ways.
+ */
+async function containingRoot(roots, target) {
+    for (const root of roots) {
+        if (isWithin(await canonicalize(node_1.path.resolve(root)), target))
+            return root;
+    }
+    return undefined;
+}
+/** Matches Linux MAXSYMLINKS, the threshold at which `realpath` itself reports ELOOP. */
+const MAX_SYMLINK_HOPS = 40;
+/** The `code` of a Node system error, or `undefined` for anything else. */
+function errnoCode(err) {
+    const code = err?.code;
+    return typeof code === 'string' ? code : undefined;
+}
+/**
+ * Fully resolve `abs`: `realpath` the longest existing ancestor and re-append
+ * the rest, but never re-append a component that is itself a symlink — read the
+ * link and continue from its target instead. This handles paths being created
+ * (write/edit) without letting a symlink leaf (e.g. a dangling one pointing
+ * outside a confinement root) slip through unresolved.
+ *
+ * Returns a symlink-free path or throws an errno-carrying error (`ELOOP` for a
+ * cycle or more than {@link MAX_SYMLINK_HOPS} links, the `lstat`/`realpath`
+ * error for an unreadable component); it never returns `abs` unresolved. Only
+ * symlink hops count against the cap, so any depth of not-yet-existing
+ * directories still resolves.
+ */
+async function canonicalize(abs) {
+    const tail = [];
+    let prefix = abs;
+    let hops = 0;
+    for (;;) {
+        let real;
+        try {
+            real = await fs.realpath(prefix);
+        }
+        catch (realpathErr) {
+            let isLink;
+            try {
+                isLink = (await fs.lstat(prefix)).isSymbolicLink();
+            }
+            catch (lstatErr) {
+                const code = errnoCode(lstatErr);
+                if (code !== 'ENOENT' && code !== 'ENOTDIR')
+                    throw lstatErr;
+                const parent = node_1.path.dirname(prefix);
+                if (parent === prefix)
+                    throw lstatErr;
+                tail.push(node_1.path.basename(prefix));
+                prefix = parent;
+                continue;
+            }
+            if (!isLink)
+                throw realpathErr;
+            if (++hops > MAX_SYMLINK_HOPS) {
+                throw Object.assign(new Error('too many levels of symbolic links'), { code: 'ELOOP' });
+            }
+            prefix = node_1.path.resolve(node_1.path.dirname(prefix), await fs.readlink(prefix));
+            continue;
+        }
+        return tail.length ? node_1.path.join(real, ...tail.reverse()) : real;
+    }
+}
+/**
+ * Resolve `p` against `root` and confine it to `root` or one of `allowedRoots`
+ * (absolute paths, resolved at check time exactly like `root`).
+ *
+ * Absolute and relative inputs go through the same canonicalise-then-contain
+ * check — an absolute path that lands inside a permitted root is accepted,
+ * only paths that resolve *outside* all of them are rejected. Every symlink in
+ * `p` (including the leaf, even a dangling one) is resolved before the
+ * confinement check, and the resolved path is what the caller then operates
+ * on, so a symlink inside `root` that points outside it can neither pass the
+ * check nor be followed afterwards. `..` is collapsed lexically before any
+ * symlink is followed. A path that cannot be resolved (symlink loop, unreadable
+ * component) is rejected with a `ToolError` naming `p`, never the host's
+ * absolute path.
+ *
+ * Residual TOCTOU: a component could still be swapped for a symlink between this
+ * call and the eventual `fs` operation. Closing that fully needs per-component
+ * `O_NOFOLLOW`/`openat`, which Node does not expose ergonomically; this is why a
+ * sandbox is still recommended for the toolset as a whole.
+ */
+async function confineToRoot(root, p, opts) {
+    const allowedRoots = opts?.allowedRoots ?? [];
+    const realRoot = await canonicalize(node_1.path.resolve(root));
+    let real;
+    try {
+        real = await canonicalize(node_1.path.resolve(realRoot, p));
+    }
+    catch (err) {
+        throw new ToolError_1.ToolError(fsErrorMessage(err, `path ${JSON.stringify(p)}`));
+    }
+    if (isWithin(realRoot, real) || (await containingRoot(allowedRoots, real)) !== undefined) {
+        return real;
+    }
+    const permitted = allowedRoots.length ?
+        "the session's working directory and its other permitted directories"
+        : "the session's working directory";
+    throw new ToolError_1.ToolError(`path ${JSON.stringify(p)} is outside ${permitted}`);
+}
+/**
+ * Atomically write `content` to `targetPath`: write a sibling temp file, fsync
+ * it, then rename over the target. The rename is atomic on most filesystems, so
+ * a crash mid-write never leaves the target half-written.
+ */
+async function atomicWriteFile(targetPath, content) {
+    const dir = node_1.path.dirname(targetPath);
+    const tempPath = node_1.path.join(dir, `.tmp-${process.pid}-${node_1.crypto.randomUUID()}`);
+    let handle;
+    try {
+        handle = await fs.open(tempPath, 'wx', exports.FILE_CREATE_MODE);
+        await handle.writeFile(content, 'utf-8');
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await fs.rename(tempPath, targetPath);
+    }
+    catch (err) {
+        if (handle)
+            await handle.close().catch(() => { });
+        await fs.unlink(tempPath).catch(() => { });
+        throw err;
+    }
+}
+/**
+ * Map a thrown filesystem error to a consistent, language-independent message,
+ * so the model sees the same wording regardless of the runtime (Node's raw
+ * `ENOENT: no such file...` text would otherwise leak through). Codes we don't
+ * special-case render as the bare code, never Node's message, which embeds the
+ * host's absolute path.
+ */
+function fsErrorMessage(err, file) {
+    const code = errnoCode(err);
+    switch (code) {
+        case 'ENOENT':
+            return `${file}: no such file or directory`;
+        case 'EACCES':
+        case 'EPERM':
+            return `${file}: permission denied`;
+        case 'ENOTDIR':
+            return `${file}: not a directory`;
+        case 'EISDIR':
+            return `${file}: is a directory`;
+        case 'ELOOP':
+            return `${file}: too many levels of symbolic links`;
+        case 'ENAMETOOLONG':
+            return `${file}: file name too long`;
+        case 'ENOSPC':
+            return `${file}: no space left on device`;
+        case 'EMFILE':
+        case 'ENFILE':
+            return `${file}: too many open files`;
+        default:
+            return `${file}: ${code !== undefined ? `i/o error (${code})` : 'i/o error'}`;
+    }
+}