@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/safe-bash/commands/python/index.js

@@ -1,4 +1,3 @@
-import "../../portable-buffer.js";
 import { PythonFileSystem, PythonStatTranslator } from "@poe-platform/safe-fs/core";
 import { validateExitCode } from '../../contracts/command.js';
 import { openCommandFile } from '../../contracts/filesystem-descriptor.js';
@@ -28,17 +27,19 @@ export function createPythonCommands(options) {
         throw new TypeError('Python onDiagnostic must be a function');
     if (options.environment && options.provisioning)
         throw new TypeError('A borrowed Python environment cannot be combined with provisioning options');
-    const maxTransferBytes = options.maxTransferBytes ?? 65536;
+    const maxTransferBytes = options.maxTransferBytes ?? Infinity;
+    // Transport chunks keep shared buffers finite without imposing an I/O quota.
+    const transferChunkBytes = Math.min(maxTransferBytes, 65536);
     const maxOpenFiles = options.maxOpenFiles;
     const maxConcurrentWorkers = options.maxConcurrentWorkers ?? Infinity;
     const maxInputChunkBytes = options.maxInputChunkBytes ?? Infinity;
-    if (options.maxConcurrentWorkers !== undefined && (!Number.isSafeInteger(maxConcurrentWorkers) || maxConcurrentWorkers < 1))
+    if (maxConcurrentWorkers !== Infinity && (!Number.isSafeInteger(maxConcurrentWorkers) || maxConcurrentWorkers < 1))
         throw new RangeError('Invalid Python worker concurrency limit');
-    if (options.maxInputChunkBytes !== undefined && (!Number.isSafeInteger(maxInputChunkBytes) || maxInputChunkBytes < 1))
+    if (maxInputChunkBytes !== Infinity && (!Number.isSafeInteger(maxInputChunkBytes) || maxInputChunkBytes < 1))
         throw new RangeError('Invalid Python input chunk limit');
     let activeWorkers = 0;
     for (const size of [maxTransferBytes, maxOpenFiles, options.maxDirectoryEntries])
-        if (size !== undefined && (!Number.isSafeInteger(size) || size < 1))
+        if (size !== undefined && size !== Infinity && (!Number.isSafeInteger(size) || size < 1))
             throw new RangeError('Invalid Python resource limit');
     const runtimeMount = options.runtimeMount ?? '/.pyodide-runtime';
     if (!runtimeMount.startsWith('/') || runtimeMount === '/' || runtimeMount.slice(1).includes('/') || runtimeMount.includes('\0') || runtimeMount.split('/').some(part => part === '..' || part === '.'))
@@ -205,7 +206,7 @@ export function createPythonCommands(options) {
             if (options.createCapabilities) {
                 const capabilityInput = { async *[Symbol.asyncIterator]() {
                         while (true) {
-                            const bytes = await dispatch({ op: 'stdin', args: [maxTransferBytes] });
+                            const bytes = await dispatch({ op: 'stdin', args: [transferChunkBytes] });
                             if (!bytes.length)
                                 break;
                             yield Uint8Array.from(bytes);
@@ -318,7 +319,7 @@ export function createPythonCommands(options) {
             else {
                 let shared;
                 try {
-                    shared = new SharedArrayBuffer(8 + maxTransferBytes * 6 + 65536);
+                    shared = new SharedArrayBuffer(8 + transferChunkBytes * 6 + 65536);
                 }
                 catch (reason) {
                     throw reportPythonFailure('transport-unavailable', reason, options.onDiagnostic);
@@ -433,7 +434,7 @@ export function createPythonCommands(options) {
                     }
                     if (settled)
                         return;
-                    const start = { type: 'start', shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes, ...(packages ? { packages } : {}), installOnly: !!installation };
+                    const start = { type: 'start', shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes: transferChunkBytes, ...(packages ? { packages } : {}), installOnly: !!installation };
                     signal.throwIfAborted();
                     try {
                         endpoint.postMessage(start);
@@ -506,6 +507,7 @@ export { createPythonPackageCache } from './cache.js';
 export { createPythonExecutorPool } from './executor-pool.js';
 export { createPythonJspiExecutor } from './jspi.js';
 export { createPythonJspiAssets } from './jspi-assets.js';
+export { installPythonLlmDependencies, pythonLlmDependencies } from './llm-dependencies.js';
 export { createPythonJspiTrampoline, createPythonJspiNativeCall, createPythonJspiStatResult } from './jspi-trampoline.js';
 export { PythonFailure, inspectPythonCapabilities } from './diagnostics.js';
 //# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/python/llm-capability.js

@@ -1,4 +1,4 @@
-import { loadLlmStoredSchema, selectLlmModelByQuery, getLlmModelAliases, createLlmConfiguration, createLlmTemplateStore, evaluateLlmTemplate, findExtractedRange, llmTemplateUsesInput, validateLlmTemplateParameters } from "../../../safe-bash-command-llm/index.js";
+import { parseLlmSchemaDsl, loadLlmStoredSchema, selectLlmModelByQuery, getLlmModelAliases, createLlmConfiguration, createLlmTemplateStore, evaluateLlmTemplate, findExtractedRange, llmTemplateUsesInput, validateLlmTemplateParameters } from "../../../safe-bash-command-llm/index.js";
 import { sniffMimeType } from '../llm/mime.js';
 import { pathOf } from '../internal.js';
 function record(value) {
@@ -231,6 +231,36 @@ export function createPythonLlmCapability(context, service, options = {}) {
             }
             for (const value of inputs) {
                 const attachment = record(value);
+                if (attachment.content !== undefined) {
+                    const content = attachment.content;
+                    if (!Array.isArray(content) || !content.every(byte => typeof byte === 'number' && Number.isInteger(byte) && byte >= 0 && byte <= 255))
+                        throw new TypeError('Invalid inline attachment bytes');
+                    if (attachment.path !== undefined || attachment.url !== undefined)
+                        throw new TypeError('Invalid inline attachment location');
+                    if (attachment.mimeType !== undefined && typeof attachment.mimeType !== 'string')
+                        throw new TypeError('Invalid attachment MIME type');
+                    if (content.length > inputLimit - admitted)
+                        throw new RangeError('LLM input byte limit exceeded');
+                    admitted += content.length;
+                    context.inputBudget?.check(admitted);
+                    const bytes = Uint8Array.from(content);
+                    const controller = new AbortController();
+                    const source = { bytes: (async function* () {
+                            for (let offset = 0; offset < bytes.length; offset += 16384) {
+                                signal.throwIfAborted();
+                                controller.signal.throwIfAborted();
+                                const chunk = bytes.subarray(offset, offset + 16384);
+                                if (chunk.byteLength > inputLimit - consumed)
+                                    throw new RangeError('LLM input byte limit exceeded');
+                                consumed += chunk.byteLength;
+                                context.inputBudget?.check(consumed);
+                                yield chunk;
+                            }
+                        })(), async dispose() { controller.abort(); } };
+                    sources.push(source);
+                    attachments.push({ mimeType: attachment.mimeType ?? sniffMimeType('', bytes.subarray(0, 4096)), source });
+                    continue;
+                }
                 if (typeof attachment.path !== 'string' || !attachment.path || attachment.path.includes('\0') || attachment.path.includes('://'))
                     throw new TypeError('Attachment requires a canonical filesystem path');
                 if (attachment.mimeType !== undefined && typeof attachment.mimeType !== 'string')
@@ -347,6 +377,23 @@ export function createPythonLlmCapability(context, service, options = {}) {
             const operation = record(value);
             const payload = record(operation.payload ?? {});
             jsonBytes(payload, bufferedInputLimit, 'input');
+            if (operation.operation === 'schema_dsl') {
+                if (typeof payload.schema !== 'string' || typeof payload.multi !== 'boolean')
+                    throw new TypeError('Invalid schema DSL input');
+                const result = parseLlmSchemaDsl(payload.schema, payload.multi);
+                jsonBytes(result, bufferedLimit);
+                return result;
+            }
+            if (operation.operation === 'attachment_type') {
+                const prefix = payload.prefix;
+                if (typeof payload.path !== 'string' || !Array.isArray(prefix) || prefix.length > 4096
+                    || prefix.some(byte => typeof byte !== 'number' || !Number.isInteger(byte) || byte < 0 || byte > 255)) {
+                    throw new TypeError('Invalid bounded attachment prefix');
+                }
+                const result = sniffMimeType(payload.path, Uint8Array.from(prefix));
+                jsonBytes(result, bufferedLimit);
+                return result;
+            }
             if (operation.operation === 'load_schema') {
                 const id = payload.schema_id;
                 if (typeof id !== 'string' || !id || id.includes('\0'))
@@ -363,6 +410,16 @@ export function createPythonLlmCapability(context, service, options = {}) {
                 jsonBytes(result, bufferedLimit);
                 return result;
             }
+            if (operation.operation === 'resolve_model') {
+                const configuration = createLlmConfiguration(configurationContext(context, payload, signal));
+                const selected = payload.model ?? await configuration.defaultModel();
+                if (selected !== undefined && typeof selected !== 'string')
+                    throw new TypeError('Model must be a string');
+                const identity = selected === undefined ? undefined : await configuration.resolveAlias(selected);
+                const resolved = service.resolve(identity).model.id;
+                jsonBytes(resolved, bufferedLimit);
+                return resolved;
+            }
             if (operation.operation === 'select_model') {
                 const queries = payload.queries;
                 if (!Array.isArray(queries) || !queries.length || queries.some(query => typeof query !== 'string'))
@@ -377,7 +434,13 @@ export function createPythonLlmCapability(context, service, options = {}) {
                 const aliases = await configuration.aliases();
                 const models = service.models.map(entry => ({
                     id: entry.model.id, aliases: getLlmModelAliases(entry, aliases), capabilities: [...entry.model.capabilities ?? []],
-                    metadata: { provider: entry.provider.name, attachmentTypes: [...entry.model.attachmentTypes ?? []], outputType: entry.model.outputType ?? 'text/plain' },
+                    metadata: { ...(entry.model.options === undefined ? {} : { options: Object.fromEntries(Object.entries(entry.model.options).map(([name, option]) => [name, {
+                                    type: option.type,
+                                    ...(option.minimum === undefined ? {} : { minimum: option.minimum }),
+                                    ...(option.maximum === undefined ? {} : { maximum: option.maximum }),
+                                    ...(option.nullable === undefined ? {} : { nullable: option.nullable }),
+                                    ...(option.description === undefined ? {} : { description: option.description }),
+                                }])) }), provider: entry.provider.name, attachmentTypes: [...entry.model.attachmentTypes ?? []], outputType: entry.model.outputType ?? 'text/plain' },
                 }));
                 jsonBytes(models, bufferedLimit);
                 return models;

package/dist/safe-bash/commands/python/llm-dependencies.d.ts

@@ -0,0 +1,27 @@
+/** Pinned build-time inputs for the offline LLM Python runtime. No runtime fetches. */
+export declare const pythonLlmDependencies: Readonly<{
+    pyodideVersion: "314.0.6";
+    baseUrl: "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/";
+    archives: readonly Readonly<{
+        fileName: string;
+        byteLength: number;
+        sha256: string;
+    }>[];
+    nativeModules: readonly Readonly<{
+        archive: "pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl";
+        path: "pydantic_core/_pydantic_core.cpython-314-wasm32-emscripten.so";
+        sha256: "94477475eb48c67b6b25fd47a7955c1d01479f7971522aff90215bb517be8246";
+    }>[];
+}>;
+export interface PythonLlmDependencyArchive {
+    readonly fileName: string;
+    readonly bytes: Uint8Array;
+}
+/** Call during loadRuntime, with statically bundled wheels and registered native modules. */
+export declare function installPythonLlmDependencies(runtime: {
+    readonly version: string;
+    unpackArchive(bytes: Uint8Array, format: 'zip', options: {
+        extractDir: string;
+    }): void;
+}, archives: readonly PythonLlmDependencyArchive[]): Promise<void>;
+//# sourceMappingURL=llm-dependencies.d.ts.map

package/dist/safe-bash/commands/python/llm-dependencies.js

@@ -0,0 +1,66 @@
+/** Pinned build-time inputs for the offline LLM Python runtime. No runtime fetches. */
+export const pythonLlmDependencies = Object.freeze({
+    pyodideVersion: '314.0.6',
+    baseUrl: 'https://cdn.jsdelivr.net/pyodide/v314.0.6/full/',
+    archives: Object.freeze([
+        {
+            "fileName": "typing_extensions-4.15.0-py3-none-any.whl",
+            "byteLength": 44613,
+            "sha256": "3f122252f0d498d80f7a684cc1d8baa6fa65b75e99447d77a6dd90e0f04302e3"
+        },
+        {
+            "fileName": "typing_inspection-0.4.2-py3-none-any.whl",
+            "byteLength": 14610,
+            "sha256": "c9270737700f07813e1a87b63138993997afedbd2548f20fa739cc398f1b9f2f"
+        },
+        {
+            "fileName": "annotated_types-0.7.0-py3-none-any.whl",
+            "byteLength": 11963,
+            "sha256": "6b34f564725f8d309442f8d15abcceed1bf140fe2412e2c58da721426ae2222e"
+        },
+        {
+            "fileName": "pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+            "byteLength": 1310163,
+            "sha256": "9802bd7a5e6679ec4c13be778f19f021e6147459c89cc916b913f7970f86dddb"
+        },
+        {
+            "fileName": "pydantic-2.12.5-py3-none-any.whl",
+            "byteLength": 463578,
+            "sha256": "52d15d19fbe2a62ac9b63348df7b38e5ebb186063a9b923a837dd6e43273b414"
+        }
+    ].map(archive => Object.freeze(archive))),
+    nativeModules: Object.freeze([Object.freeze({
+            archive: 'pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl',
+            path: 'pydantic_core/_pydantic_core.cpython-314-wasm32-emscripten.so',
+            sha256: '94477475eb48c67b6b25fd47a7955c1d01479f7971522aff90215bb517be8246',
+        })]),
+});
+/** Call during loadRuntime, with statically bundled wheels and registered native modules. */
+export async function installPythonLlmDependencies(runtime, archives) {
+    if (runtime.version !== pythonLlmDependencies.pyodideVersion)
+        throw new Error('Python LLM dependencies require Pyodide 314.0.6');
+    const supplied = new Map(archives.map(archive => [archive.fileName, archive.bytes]));
+    if (archives.length !== pythonLlmDependencies.archives.length || supplied.size !== archives.length
+        || pythonLlmDependencies.archives.some(archive => !supplied.has(archive.fileName))) {
+        throw new Error('A complete pinned Python LLM dependency bundle is required');
+    }
+    // Snapshot every input before hashing or extracting, so callers cannot change
+    // bytes while an asynchronous digest is pending. Reject sizes before copying.
+    const snapshots = pythonLlmDependencies.archives.map(archive => {
+        const bytes = supplied.get(archive.fileName);
+        if (!(bytes instanceof Uint8Array) || bytes.byteLength !== archive.byteLength) {
+            throw new Error('Python LLM dependency size or digest mismatch: ' + archive.fileName);
+        }
+        return { archive, bytes: new Uint8Array(bytes) };
+    });
+    for (const { archive, bytes } of snapshots) {
+        const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', bytes));
+        const sha256 = Array.from(digest, value => value.toString(16).padStart(2, '0')).join('');
+        if (sha256 !== archive.sha256)
+            throw new Error('Python LLM dependency digest mismatch: ' + archive.fileName);
+    }
+    // Validate the whole bundle before touching the interpreter filesystem.
+    for (const { bytes } of snapshots)
+        runtime.unpackArchive(bytes, 'zip', { extractDir: '/lib/python3.14/site-packages' });
+}
+//# sourceMappingURL=llm-dependencies.js.map

package/dist/safe-bash/commands/python/llm-module.js

@@ -1,4 +1,5 @@
-/** Python source bundled as data; a host bridge must install it as poe_llm. */
+import { pythonLlmReferenceModule } from './llm-reference-module.js';
+/** Python source bundled as data; a host bridge installs lazy public modules. */
 const pythonLlmModule = /* @__PURE__ */ (() => String.raw `
 """Async Python workflows for the invocation-owned JavaScript LLM service."""
 from __future__ import annotations
@@ -489,13 +490,14 @@ class _SafeLlmLoader:
   self._source = source
   self._spec = spec
  def find_spec(self, fullname, path=None, target=None):
-  if fullname == 'poe_llm':
+  if fullname in ('poe_llm', 'llm'):
    return self._spec(fullname, self, origin='poe_llm.py')
  def create_module(self, spec):
   return None
  def exec_module(self, module):
-  module.__file__ = 'poe_llm.py'
-  exec(compile(self._source, 'poe_llm.py', 'exec'), module.__dict__)
+  module.__file__ = module.__name__ + '.py'
+  source = self._source if module.__name__ == 'poe_llm' else ${JSON.stringify(pythonLlmReferenceModule)}
+  exec(compile(source, module.__file__, 'exec'), module.__dict__)
 _safe_llm_sys.meta_path.insert(0, _SafeLlmLoader(_safe_llm_source, _safe_llm_imports.ModuleSpec))
 del _SafeLlmLoader, _safe_llm_sys, _safe_llm_imports
 `);

package/dist/safe-bash/commands/python/llm-reference-module.d.ts

@@ -0,0 +1,3 @@
+/** Public Python calling conventions over the invocation-owned internal client. */
+export declare const pythonLlmReferenceModule: string;
+//# sourceMappingURL=llm-reference-module.d.ts.map