@poe-platform/safe-bash 0.1.802 → 0.1.804

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