@psnext/slingcli 2.4.20260516-1 → 2.4.20260520-2

package/node_modules/@earendil-works/pi-ai/dist/models.generated.js

@@ -908,8 +908,8 @@ export const MODELS = {
                 cacheRead: 0,
                 cacheWrite: 0,
             },
-            contextWindow: 256000,
-            maxTokens: 256000,
+            contextWindow: 262143,
+            maxTokens: 16000,
         },
         "moonshotai.kimi-k2.5": {
             id: "moonshotai.kimi-k2.5",
@@ -925,8 +925,8 @@ export const MODELS = {
                 cacheRead: 0,
                 cacheWrite: 0,
             },
-            contextWindow: 256000,
-            maxTokens: 256000,
+            contextWindow: 262143,
+            maxTokens: 16000,
         },
         "nvidia.nemotron-nano-12b-v2": {
             id: "nvidia.nemotron-nano-12b-v2",
@@ -3479,6 +3479,24 @@ export const MODELS = {
             contextWindow: 160000,
             maxTokens: 160000,
         },
+        "accounts/fireworks/models/deepseek-v4-flash": {
+            id: "accounts/fireworks/models/deepseek-v4-flash",
+            name: "DeepSeek V4 Flash",
+            api: "anthropic-messages",
+            provider: "fireworks",
+            baseUrl: "https://api.fireworks.ai/inference",
+            compat: { "sendSessionAffinityHeaders": true, "supportsEagerToolInputStreaming": false, "supportsCacheControlOnTools": false, "supportsLongCacheRetention": false },
+            reasoning: true,
+            input: ["text"],
+            cost: {
+                input: 0.14,
+                output: 0.28,
+                cacheRead: 0.03,
+                cacheWrite: 0,
+            },
+            contextWindow: 1000000,
+            maxTokens: 384000,
+        },
         "accounts/fireworks/models/deepseek-v4-pro": {
             id: "accounts/fireworks/models/deepseek-v4-pro",
             name: "DeepSeek V4 Pro",
@@ -4511,6 +4529,24 @@ export const MODELS = {
             contextWindow: 1048576,
             maxTokens: 65536,
         },
+        "gemini-3.5-flash": {
+            id: "gemini-3.5-flash",
+            name: "Gemini 3.5 Flash",
+            api: "google-generative-ai",
+            provider: "google",
+            baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+            reasoning: true,
+            thinkingLevelMap: { "off": null },
+            input: ["text", "image"],
+            cost: {
+                input: 1.5,
+                output: 9,
+                cacheRead: 0.15,
+                cacheWrite: 0,
+            },
+            contextWindow: 1048576,
+            maxTokens: 65536,
+        },
         "gemini-flash-latest": {
             id: "gemini-flash-latest",
             name: "Gemini Flash Latest",
@@ -7335,9 +7371,9 @@ export const MODELS = {
         "big-pickle": {
             id: "big-pickle",
             name: "Big Pickle",
-            api: "anthropic-messages",
+            api: "openai-completions",
             provider: "opencode",
-            baseUrl: "https://opencode.ai/zen",
+            baseUrl: "https://opencode.ai/zen/v1",
             reasoning: true,
             input: ["text"],
             cost: {
@@ -7542,6 +7578,24 @@ export const MODELS = {
             contextWindow: 1048576,
             maxTokens: 65536,
         },
+        "gemini-3.5-flash": {
+            id: "gemini-3.5-flash",
+            name: "Gemini 3.5 Flash",
+            api: "google-generative-ai",
+            provider: "opencode",
+            baseUrl: "https://opencode.ai/zen/v1",
+            reasoning: true,
+            thinkingLevelMap: { "off": null },
+            input: ["text", "image"],
+            cost: {
+                input: 1.5,
+                output: 9,
+                cacheRead: 0.15,
+                cacheWrite: 0,
+            },
+            contextWindow: 1048576,
+            maxTokens: 65536,
+        },
         "glm-5": {
             id: "glm-5",
             name: "GLM-5",
@@ -9054,7 +9108,7 @@ export const MODELS = {
                 cacheRead: 0.024999999999999998,
                 cacheWrite: 0.08333333333333334,
             },
-            contextWindow: 1048576,
+            contextWindow: 1000000,
             maxTokens: 8192,
         },
         "google/gemini-2.0-flash-lite-001": {
@@ -9261,6 +9315,23 @@ export const MODELS = {
             contextWindow: 1048756,
             maxTokens: 65536,
         },
+        "google/gemini-3.5-flash": {
+            id: "google/gemini-3.5-flash",
+            name: "Google: Gemini 3.5 Flash",
+            api: "openai-completions",
+            provider: "openrouter",
+            baseUrl: "https://openrouter.ai/api/v1",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: {
+                input: 1.5,
+                output: 9,
+                cacheRead: 0.15,
+                cacheWrite: 0.08333333333333334,
+            },
+            contextWindow: 1048576,
+            maxTokens: 65536,
+        },
         "google/gemma-3-12b-it": {
             id: "google/gemma-3-12b-it",
             name: "Google: Gemma 3 12B",
@@ -9406,9 +9477,9 @@ export const MODELS = {
             reasoning: false,
             input: ["text"],
             cost: {
-                input: 0.3,
-                output: 2.5,
-                cacheRead: 0.06,
+                input: 0.075,
+                output: 0.625,
+                cacheRead: 0.015,
                 cacheWrite: 0,
             },
             contextWindow: 262144,
@@ -11934,13 +12005,13 @@ export const MODELS = {
             reasoning: true,
             input: ["text", "image"],
             cost: {
-                input: 0.14,
+                input: 0.13899999999999998,
                 output: 1,
-                cacheRead: 0.049999999999999996,
+                cacheRead: 0,
                 cacheWrite: 0,
             },
             contextWindow: 262144,
-            maxTokens: 81920,
+            maxTokens: 4096,
         },
         "qwen/qwen3.5-397b-a17b": {
             id: "qwen/qwen3.5-397b-a17b",
@@ -12053,13 +12124,13 @@ export const MODELS = {
             reasoning: true,
             input: ["text", "image"],
             cost: {
-                input: 0.15,
+                input: 0.149,
                 output: 1,
-                cacheRead: 0.049999999999999996,
+                cacheRead: 0,
                 cacheWrite: 0,
             },
             contextWindow: 262144,
-            maxTokens: 262144,
+            maxTokens: 4096,
         },
         "qwen/qwen3.6-flash": {
             id: "qwen/qwen3.6-flash",
@@ -12580,13 +12651,13 @@ export const MODELS = {
             reasoning: true,
             input: ["text"],
             cost: {
-                input: 0.98,
-                output: 3.08,
-                cacheRead: 0.182,
+                input: 0,
+                output: 0,
+                cacheRead: 0,
                 cacheWrite: 0,
             },
-            contextWindow: 202752,
-            maxTokens: 4096,
+            contextWindow: 202800,
+            maxTokens: 202800,
         },
         "z-ai/glm-5v-turbo": {
             id: "z-ai/glm-5v-turbo",
@@ -12665,9 +12736,9 @@ export const MODELS = {
             reasoning: true,
             input: ["text", "image"],
             cost: {
-                input: 0.5,
-                output: 3,
-                cacheRead: 0.049999999999999996,
+                input: 1.5,
+                output: 9,
+                cacheRead: 0.15,
                 cacheWrite: 0.08333333333333334,
             },
             contextWindow: 1048576,
@@ -13934,6 +14005,23 @@ export const MODELS = {
             contextWindow: 1000000,
             maxTokens: 64000,
         },
+        "google/gemini-3.5-flash": {
+            id: "google/gemini-3.5-flash",
+            name: "Gemini 3.5 Flash",
+            api: "anthropic-messages",
+            provider: "vercel-ai-gateway",
+            baseUrl: "https://ai-gateway.vercel.sh",
+            reasoning: true,
+            input: ["text", "image"],
+            cost: {
+                input: 1.5,
+                output: 9,
+                cacheRead: 0.15,
+                cacheWrite: 0,
+            },
+            contextWindow: 1000000,
+            maxTokens: 64000,
+        },
         "google/gemma-4-26b-a4b-it": {
             id: "google/gemma-4-26b-a4b-it",
             name: "Gemma 4 26B A4B IT",
@@ -14393,6 +14481,23 @@ export const MODELS = {
             contextWindow: 128000,
             maxTokens: 64000,
         },
+        "mistral/mistral-medium-3.5": {
+            id: "mistral/mistral-medium-3.5",
+            name: "Mistral Medium Latest",
+            api: "anthropic-messages",
+            provider: "vercel-ai-gateway",
+            baseUrl: "https://ai-gateway.vercel.sh",
+            reasoning: true,
+            input: ["text"],
+            cost: {
+                input: 1.5,
+                output: 7.5,
+                cacheRead: 0,
+                cacheWrite: 0,
+            },
+            contextWindow: 256000,
+            maxTokens: 256000,
+        },
         "mistral/mistral-small": {
             id: "mistral/mistral-small",
             name: "Mistral Small",

package/node_modules/@mariozechner/clipboard-darwin-arm64/README.md

@@ -0,0 +1,3 @@
+# `@mariozechner/clipboard-darwin-arm64`
+
+This is the **aarch64-apple-darwin** binary for `@mariozechner/clipboard`

package/node_modules/@mariozechner/{clipboard-linux-x64-gnu → clipboard-darwin-arm64}/package.json

@@ -1,23 +1,20 @@
 {
-  "name": "@mariozechner/clipboard-linux-x64-gnu",
+  "name": "@mariozechner/clipboard-darwin-arm64",
   "version": "0.3.6",
   "os": [
-    "linux"
+    "darwin"
   ],
   "cpu": [
-    "x64"
+    "arm64"
   ],
-  "main": "clipboard.linux-x64-gnu.node",
+  "main": "clipboard.darwin-arm64.node",
   "files": [
-    "clipboard.linux-x64-gnu.node"
+    "clipboard.darwin-arm64.node"
   ],
   "license": "MIT",
   "engines": {
     "node": ">= 10"
   },
-  "libc": [
-    "glibc"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/badlogic/clipboard.git"

package/node_modules/@mariozechner/clipboard-darwin-universal/README.md

@@ -0,0 +1,3 @@
+# `@mariozechner/clipboard-darwin-universal`
+
+This is the **universal-apple-darwin** binary for `@mariozechner/clipboard`

package/node_modules/@mariozechner/clipboard-darwin-universal/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@mariozechner/clipboard-darwin-universal",
+  "version": "0.3.6",
+  "os": [
+    "darwin"
+  ],
+  "main": "clipboard.darwin-universal.node",
+  "files": [
+    "clipboard.darwin-universal.node"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/badlogic/clipboard.git"
+  }
+}

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Thu, 14 May 2026 16:39:50 GMT
+ * Last updated: Tue, 19 May 2026 17:48:56 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/async_hooks.d.ts

@@ -491,6 +491,75 @@ declare module "node:async_hooks" {
          * @experimental
          */
         exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
+        /**
+         * Creates a disposable scope that enters the given store and automatically
+         * restores the previous store value when the scope is disposed. This method is
+         * designed to work with JavaScript's explicit resource management (`using` syntax).
+         *
+         * Example:
+         *
+         * ```js
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const asyncLocalStorage = new AsyncLocalStorage();
+         *
+         * {
+         *   using _ = asyncLocalStorage.withScope('my-store');
+         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
+         * }
+         *
+         * console.log(asyncLocalStorage.getStore()); // Prints: undefined
+         * ```
+         *
+         * The `withScope()` method is particularly useful for managing context in
+         * synchronous code where you want to ensure the previous store value is restored
+         * when exiting a block, even if an error is thrown.
+         *
+         * ```js
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const asyncLocalStorage = new AsyncLocalStorage();
+         *
+         * try {
+         *   using _ = asyncLocalStorage.withScope('my-store');
+         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
+         *   throw new Error('test');
+         * } catch (e) {
+         *   // Store is automatically restored even after error
+         *   console.log(asyncLocalStorage.getStore()); // Prints: undefined
+         * }
+         * ```
+         *
+         * **Important:** When using `withScope()` in async functions before the first
+         * `await`, be aware that the scope change will affect the caller's context. The
+         * synchronous portion of an async function (before the first `await`) runs
+         * immediately when called, and when it reaches the first `await`, it returns the
+         * promise to the caller. At that point, the scope change becomes visible in the
+         * caller's context and will persist in subsequent synchronous code until something
+         * else changes the scope value. For async operations, prefer using `run()` which
+         * properly isolates context across async boundaries.
+         *
+         * ```js
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const asyncLocalStorage = new AsyncLocalStorage();
+         *
+         * async function example() {
+         *   using _ = asyncLocalStorage.withScope('my-store');
+         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
+         *   await someAsyncOperation(); // Function pauses here and returns promise
+         *   console.log(asyncLocalStorage.getStore()); // Prints: my-store
+         * }
+         *
+         * // Calling without await
+         * example(); // Synchronous portion runs, then pauses at first await
+         * // After the promise is returned, the scope 'my-store' is now active in caller!
+         * console.log(asyncLocalStorage.getStore()); // Prints: my-store (unexpected!)
+         * ```
+         * @since v25.9.0
+         * @experimental
+         */
+        withScope(store: T): RunScope;
         /**
          * Transitions into the context for the remainder of the current
          * synchronous execution and then persists the store through any following
@@ -533,6 +602,45 @@ declare module "node:async_hooks" {
          */
         enterWith(store: T): void;
     }
+    /**
+     * A disposable scope returned by `asyncLocalStorage.withScope()` that
+     * automatically restores the previous store value when disposed. This class
+     * implements the [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management) protocol and is designed to work
+     * with JavaScript's `using` syntax.
+     *
+     * The scope automatically restores the previous store value when the `using` block
+     * exits, whether through normal completion or by throwing an error.
+     * @since v25.9.0
+     * @experimental
+     */
+    interface RunScope extends Disposable {
+        /**
+         * Explicitly ends the scope and restores the previous store value. This method
+         * is idempotent: calling it multiple times has the same effect as calling it once.
+         *
+         * The `[Symbol.dispose]()` method defers to `dispose()`.
+         *
+         * If `withScope()` is called without the `using` keyword, `dispose()` must be
+         * called manually to restore the previous store value. Forgetting to call
+         * `dispose()` will cause the store value to persist for the remainder of the
+         * current execution context:
+         *
+         * ```js
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const storage = new AsyncLocalStorage();
+         *
+         * // Without using, the scope must be disposed manually
+         * const scope = storage.withScope('my-store');
+         * // storage.getStore() === 'my-store' here
+         *
+         * scope.dispose(); // Restore previous value
+         * // storage.getStore() === undefined here
+         * ```
+         * @since v25.9.0
+         */
+        dispose(): void;
+    }
     /**
      * @since v17.2.0, v16.14.0
      * @return A map of provider types to the corresponding numeric id.

package/node_modules/@types/node/crypto.d.ts

@@ -3778,7 +3778,7 @@ declare module "node:crypto" {
         interface CShakeParams extends Algorithm {
             customization?: NodeJS.BufferSource;
             functionName?: NodeJS.BufferSource;
-            length: number;
+            outputLength: number;
         }
         interface ContextParams extends Algorithm {
             context?: NodeJS.BufferSource;
@@ -3815,6 +3815,10 @@ declare module "node:crypto" {
             hash: HashAlgorithmIdentifier;
             length?: number;
         }
+        interface KangarooTwelveParams {
+            customization?: NodeJS.BufferSource;
+            outputLength: number;
+        }
         interface JsonWebKey {
             alg?: string;
             crv?: string;
@@ -3849,7 +3853,7 @@ declare module "node:crypto" {
         }
         interface KmacParams extends Algorithm {
             customization?: NodeJS.BufferSource;
-            length: number;
+            outputLength: number;
         }
         interface Pbkdf2Params extends Algorithm {
             hash: HashAlgorithmIdentifier;
@@ -3884,6 +3888,10 @@ declare module "node:crypto" {
         interface RsaPssParams extends Algorithm {
             saltLength: number;
         }
+        interface TurboShakeParams {
+            domainSeparation?: number;
+            outputLength: number;
+        }
         interface Crypto {
             readonly subtle: SubtleCrypto;
             getRandomValues<
@@ -3945,7 +3953,10 @@ declare module "node:crypto" {
                 extractable: boolean,
                 keyUsages: readonly KeyUsage[],
             ): Promise<CryptoKey>;
-            digest(algorithm: AlgorithmIdentifier | CShakeParams, data: NodeJS.BufferSource): Promise<ArrayBuffer>;
+            digest(
+                algorithm: AlgorithmIdentifier | CShakeParams | TurboShakeParams | KangarooTwelveParams,
+                data: NodeJS.BufferSource,
+            ): Promise<ArrayBuffer>;
             encapsulateBits(
                 encapsulationAlgorithm: AlgorithmIdentifier,
                 encapsulationKey: CryptoKey,

package/node_modules/@types/node/fs/promises.d.ts

@@ -37,6 +37,7 @@ declare module "node:fs/promises" {
         WriteVResult,
     } from "node:fs";
     import { Stream } from "node:stream";
+    import { ByteReadableStream, Transform, Writer } from "node:stream/iter";
     import { ReadableStream } from "node:stream/web";
     interface FileChangeInfo<T extends string | Buffer> {
         eventType: WatchEventType;
@@ -85,6 +86,57 @@ declare module "node:fs/promises" {
     interface ReadableWebStreamOptions {
         autoClose?: boolean | undefined;
     }
+    interface PullOptions extends Abortable {
+        /**
+         * Close the file handle when the stream ends.
+         * @default false
+         */
+        autoClose?: boolean | undefined;
+        /**
+         * Byte offset to begin reading from. When specified,
+         * reads use explicit positioning (`pread` semantics).
+         */
+        start?: number | undefined;
+        /**
+         * Maximum number of bytes to read before ending the
+         * iterator. Reads stop when `limit` bytes have been delivered or EOF is
+         * reached, whichever comes first.
+         */
+        limit?: number | undefined;
+        /**
+         * Size in bytes of the buffer allocated for each
+         * read operation.
+         * @default 131072
+         */
+        chunkSize?: number | undefined;
+    }
+    interface WriterOptions {
+        /**
+         * Close the file handle when the writer ends or fails.
+         * @default false
+         */
+        autoClose?: boolean | undefined;
+        /**
+         * Byte offset to start writing at. When specified,
+         * writes use explicit positioning.
+         */
+        start?: number | undefined;
+        /**
+         * Maximum number of bytes the writer will accept.
+         * Async writes (`write()`, `writev()`) that would exceed the limit reject
+         * with `ERR_OUT_OF_RANGE`. Sync writes (`writeSync()`, `writevSync()`)
+         * return `false`.
+         */
+        limit?: number | undefined;
+        /**
+         * Maximum chunk size in bytes for synchronous write
+         * operations. Writes larger than this threshold fall back to async I/O.
+         * Set this to match the reader's `chunkSize` for optimal `pipeTo()`
+         * performance.
+         * @default 131072
+         */
+        chunkSize?: number | undefined;
+    }
     // TODO: Add `EventEmitter` close
     interface FileHandle {
         /**
@@ -202,6 +254,41 @@ declare module "node:fs/promises" {
          * @return Fulfills with `undefined` upon success.
          */
         datasync(): Promise<void>;
+        /**
+         * Return the file contents as an async iterable using the
+         * [`node:stream/iter`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html) pull model. Reads are performed in `chunkSize`-byte
+         * chunks (default 128 KB). If transforms are provided, they are applied
+         * via [`stream/iter pull()`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html#pullsource-transforms-options).
+         *
+         * The file handle is locked while the iterable is being consumed and unlocked
+         * when iteration completes, an error occurs, or the consumer breaks.
+         *
+         * This function is only available when the `--experimental-stream-iter` flag is
+         * enabled.
+         *
+         * ```js
+         * import { open } from 'node:fs/promises';
+         * import { text } from 'node:stream/iter';
+         * import { compressGzip } from 'node:zlib/iter';
+         *
+         * const fh = await open('input.txt', 'r');
+         *
+         * // Read as text
+         * console.log(await text(fh.pull({ autoClose: true })));
+         *
+         * // Read 1 KB starting at byte 100
+         * const fh2 = await open('input.txt', 'r');
+         * console.log(await text(fh2.pull({ start: 100, limit: 1024, autoClose: true })));
+         *
+         * // Read with compression
+         * const fh3 = await open('input.txt', 'r');
+         * const compressed = fh3.pull(compressGzip(), { autoClose: true });
+         * ```
+         * @since v25.9.0
+         * @experimental
+         */
+        pull(...transforms: Transform[]): ByteReadableStream;
+        pull(...args: [...transforms: Transform[], options: PullOptions]): ByteReadableStream;
         /**
          * Request that all data for the open file descriptor is flushed to the storage
          * device. The specific implementation is operating system and device specific.
@@ -450,6 +537,45 @@ declare module "node:fs/promises" {
             buffers: TBuffers,
             position?: number,
         ): Promise<WriteVResult<TBuffers>>;
+        /**
+         * Return a [`node:stream/iter`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html) writer backed by this file handle.
+         *
+         * The writer supports both `Symbol.asyncDispose` and `Symbol.dispose`:
+         *
+         * * `await using w = fh.writer()` — if the writer is still open (no `end()`
+         *   called), `asyncDispose` calls `fail()`. If `end()` is pending, it waits
+         *   for it to complete.
+         * * `using w = fh.writer()` — calls `fail()` unconditionally.
+         *
+         * The `writeSync()` and `writevSync()` methods enable the try-sync fast path
+         * used by [`stream/iter pipeTo()`](https://nodejs.org/docs/latest-v25.x/api/stream_iter.html#pipetosource-transforms-writer). When the reader's chunk size matches the
+         * writer's `chunkSize`, all writes in a `pipeTo()` pipeline complete
+         * synchronously with zero promise overhead.
+         *
+         * This function is only available when the `--experimental-stream-iter` flag is
+         * enabled.
+         *
+         * ```js
+         * import { open } from 'node:fs/promises';
+         * import { from, pipeTo } from 'node:stream/iter';
+         * import { compressGzip } from 'node:zlib/iter';
+         *
+         * // Async pipeline
+         * const fh = await open('output.gz', 'w');
+         * await pipeTo(from('Hello!'), compressGzip(), fh.writer({ autoClose: true }));
+         *
+         * // Sync pipeline with limit
+         * const src = await open('input.txt', 'r');
+         * const dst = await open('output.txt', 'w');
+         * const w = dst.writer({ limit: 1024 * 1024 }); // Max 1 MB
+         * await pipeTo(src.pull({ autoClose: true }), w);
+         * await w.end();
+         * await dst.close();
+         * ```
+         * @since v25.9.0
+         * @experimental
+         */
+        writer(options?: WriterOptions): Writer;
         /**
          * Read from a file and write to an array of [ArrayBufferView](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) s
          * @since v13.13.0, v12.17.0