@poe-platform/safe-bash 0.1.759 → 0.1.760

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

@@ -1,8 +1,12 @@
 import type { CommandContext } from '../../contracts/index.js';
 import type { LlmService } from '../llm/service.js';
 import type { PythonHostCapability } from './host-capabilities.js';
-/** Reuses the invocation's authorized service; Python receives only model data. */
-export declare function createPythonLlmCapability(context: Pick<CommandContext, 'fs' | 'cwd' | 'inputBudget'>, service: LlmService, options?: {
+export interface PythonLlmCapabilityOptions {
     readonly maxStreamChunkBytes?: number;
-}): PythonHostCapability;
+    readonly maxBufferedResponseBytes?: number;
+    readonly maxBufferedEvents?: number;
+    readonly maxMetadataBytes?: number;
+}
+/** Reuses the invocation's authorized service; Python receives only model data. */
+export declare function createPythonLlmCapability(context: Pick<CommandContext, 'fs' | 'cwd' | 'inputBudget'>, service: LlmService, options?: PythonLlmCapabilityOptions): PythonHostCapability;
 //# sourceMappingURL=llm-capability.d.ts.map

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

@@ -5,11 +5,112 @@ function record(value) {
         throw new TypeError('Expected a structured Python LLM request');
     return value;
 }
+/** Count the wire representation before retaining/serializing host metadata. */
+function jsonBytes(value, limit) {
+    if (limit === Infinity)
+        return 0;
+    let bytes = 0;
+    const ancestors = new Set();
+    const add = (size) => {
+        if (size > limit - bytes)
+            throw new RangeError('Python LLM serialized response limit exceeded');
+        bytes += size;
+    };
+    const string = (text) => {
+        add(2);
+        if (text.length > limit - bytes)
+            throw new RangeError('Python LLM serialized response limit exceeded');
+        for (let i = 0; i < text.length; i++) {
+            const point = text.codePointAt(i);
+            if (point > 65535) {
+                add(4);
+                i++;
+            }
+            else if (point === 34 || point === 92)
+                add(2);
+            else if (point < 32)
+                add([8, 9, 10, 12, 13].includes(point) ? 2 : 6);
+            else if (point >= 0xd800 && point <= 0xdfff)
+                add(6);
+            else
+                add(point < 128 ? 1 : point < 2048 ? 2 : 3);
+        }
+    };
+    const visit = (item) => {
+        if (typeof item === 'string') {
+            string(item);
+            return;
+        }
+        if (item === null || typeof item === 'boolean' || typeof item === 'number' && Number.isFinite(item)) {
+            add(JSON.stringify(item).length);
+            return;
+        }
+        if (!item || typeof item !== 'object' || ancestors.has(item))
+            throw new TypeError('Python LLM response must contain acyclic data');
+        ancestors.add(item);
+        add(2);
+        let entries = 0;
+        if (Array.isArray(item)) {
+            if (item.length > limit - bytes)
+                throw new RangeError('Python LLM serialized response limit exceeded');
+            for (let i = 0; i < item.length; i++) {
+                const descriptor = Object.getOwnPropertyDescriptor(item, String(i));
+                if (!descriptor || !('value' in descriptor))
+                    throw new TypeError('Python LLM response must contain data');
+                if (entries++)
+                    add(1);
+                visit(descriptor.value);
+            }
+        }
+        else {
+            for (const key in item) {
+                if (!Object.hasOwn(item, key))
+                    continue;
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                if (!('value' in descriptor))
+                    throw new TypeError('Python LLM response must contain data');
+                if (entries++)
+                    add(1);
+                string(key);
+                add(1);
+                visit(descriptor.value);
+            }
+        }
+        ancestors.delete(item);
+    };
+    visit(value);
+    return bytes;
+}
+function* textFragments(text, limit) {
+    let start = 0, bytes = 0;
+    for (let i = 0; i < text.length;) {
+        const point = text.codePointAt(i);
+        const width = point < 128 ? 1 : point < 2048 ? 2 : point < 65536 ? 3 : 4;
+        if (width > limit)
+            throw new RangeError('Python LLM stream chunk limit cannot fit a Unicode scalar');
+        if (width > limit - bytes) {
+            yield text.slice(start, i);
+            start = i;
+            bytes = 0;
+        }
+        bytes += width;
+        i += point > 65535 ? 2 : 1;
+    }
+    if (start < text.length || !text.length)
+        yield text.slice(start);
+}
 /** Reuses the invocation's authorized service; Python receives only model data. */
 export function createPythonLlmCapability(context, service, options = {}) {
     const chunkBytes = options.maxStreamChunkBytes ?? 16384;
     if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1)
         throw new RangeError('Invalid Python LLM stream chunk limit');
+    const bufferedLimit = options.maxBufferedResponseBytes ?? Infinity;
+    const eventLimit = options.maxBufferedEvents ?? bufferedLimit;
+    const metadataLimit = options.maxMetadataBytes ?? bufferedLimit;
+    for (const limit of [bufferedLimit, eventLimit, metadataLimit]) {
+        if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
+            throw new RangeError('Invalid Python LLM host limit');
+    }
     const prepare = async (value, signal) => {
         const payload = record(value);
         for (const key of ['template', 'conversation']) {
@@ -73,8 +174,16 @@ export function createPythonLlmCapability(context, service, options = {}) {
                     yield { type: 'bytes', data: Array.from(event.data.subarray(offset, offset + chunkBytes)) };
                 }
             }
-            else
+            else if (event.type === 'text') {
+                for (const text of textFragments(event.text, chunkBytes)) {
+                    request.signal.throwIfAborted();
+                    yield { type: 'text', text };
+                }
+            }
+            else {
+                jsonBytes(event.response, metadataLimit);
                 yield event;
+            }
         }
     };
     return {
@@ -93,19 +202,49 @@ export function createPythonLlmCapability(context, service, options = {}) {
             }
             if (operation.operation !== 'complete')
                 throw new TypeError('Unsupported Python LLM operation');
-            const text = [], data = [];
+            const request = await prepare(payload, signal);
+            const bounded = { ...request, maxOutputBytes: Math.min(request.maxOutputBytes ?? Infinity, bufferedLimit) };
+            let text = '', textBytes = 0, dataBytes = 0, received = 0;
+            const data = [];
             let response = {};
-            for await (const value of events(payload, { signal })) {
-                const event = record(value);
-                if (event.type === 'text')
-                    text.push(event.text);
-                else if (event.type === 'bytes')
+            let envelopeBytes = jsonBytes({ text: '', data: [] }, bufferedLimit);
+            const admit = (size) => {
+                if (size > bufferedLimit - envelopeBytes - textBytes - dataBytes)
+                    throw new RangeError('Python LLM buffered response limit exceeded');
+            };
+            for await (const event of service.stream(bounded)) {
+                bounded.signal.throwIfAborted();
+                if (++received > eventLimit)
+                    throw new RangeError('Python LLM buffered event limit exceeded');
+                if (event.type === 'text') {
+                    const size = bufferedLimit === Infinity || !event.text ? 0 : jsonBytes(event.text, bufferedLimit - envelopeBytes - textBytes - dataBytes + 2) - 2;
+                    admit(size);
+                    textBytes += size;
+                    if (event.text)
+                        text += event.text;
+                }
+                else if (event.type === 'bytes') {
+                    let size = 0;
+                    if (bufferedLimit !== Infinity)
+                        for (let i = 0; i < event.data.length; i++) {
+                            size += String(event.data[i]).length + (data.length || i ? 1 : 0);
+                            admit(size);
+                        }
+                    dataBytes += size;
                     for (const byte of event.data)
                         data.push(byte);
-                else if (event.type === 'response')
-                    response = { ...record(event.response) };
+                }
+                else {
+                    jsonBytes(event.response, metadataLimit);
+                    const details = record(event.response);
+                    const size = jsonBytes({ ...details, text: '', data: [] }, bufferedLimit);
+                    if (size > bufferedLimit - textBytes - dataBytes)
+                        throw new RangeError('Python LLM buffered response limit exceeded');
+                    envelopeBytes = size;
+                    response = { ...details };
+                }
             }
-            return { ...response, text: text.join(''), data };
+            return { ...response, text, data };
         },
         stream: events,
     };

package/dist/safe-bash/core.browser.js

@@ -158,7 +158,7 @@ import {
   sha256,
   sha384,
   sha512
-} from "./chunks/chunk-AYPUGSOV.js";
+} from "./chunks/chunk-CRQDMBQA.js";
 import {
   PythonFailure,
   inspectPythonCapabilities