@zenera/gym 1.1.40 → 1.1.42

package/dist/worker.js

@@ -0,0 +1,99 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { pathToFileURL } from 'node:url';
+import { parentPort } from 'node:worker_threads';
+import { createContext, HttpError, } from "./runtime.js";
+import { WorldStore } from "./store.js";
+const port = parentPort;
+if (!port) {
+    throw new Error('worker.ts must be started as a worker thread');
+}
+const stores = new Map();
+const pending = new Map();
+let calls = 0;
+const storeFor = (path) => {
+    let store = stores.get(path);
+    if (!store) {
+        store = new WorldStore(path);
+        stores.set(path, store);
+    }
+    return store;
+};
+port.on('message', (message) => {
+    if (message.type === 'close') {
+        stores.get(message.db)?.close();
+        stores.delete(message.db);
+        return;
+    }
+    if (message.type === 'synthesized') {
+        const key = `${message.id}:${message.call}`;
+        const waiter = pending.get(key);
+        pending.delete(key);
+        if (message.error !== undefined) {
+            waiter?.reject(new Error(message.error));
+        }
+        else {
+            waiter?.resolve(message.records ?? []);
+        }
+        return;
+    }
+    void run(message);
+});
+async function run(message) {
+    const { id } = message;
+    const used = new Map();
+    const record = (use) => {
+        used.set(`${use.collection}\u0000${use.type ?? ''}\u0000${use.idField ?? ''}`, use);
+    };
+    const reply = (m) => port.postMessage({ ...m, used: [...used.values()] });
+    try {
+        const mod = (await import(__rewriteRelativeImportExtension(`${pathToFileURL(message.file).href}?v=${message.version}`)));
+        const handle = (mod.default ?? mod.handle);
+        if (typeof handle !== 'function') {
+            reply({
+                type: 'done',
+                id,
+                ok: false,
+                fault: 'exports no handler: write `export default async function handle(req, ctx)`',
+            });
+            return;
+        }
+        const store = storeFor(message.db);
+        const ctx = createContext(message.input, store, (request) => {
+            const call = ++calls;
+            return new Promise((resolve, reject) => {
+                pending.set(`${id}:${call}`, { resolve, reject });
+                port.postMessage({
+                    type: 'synthesize',
+                    id,
+                    call,
+                    db: message.db,
+                    request,
+                });
+            });
+        }, message.bindings, record);
+        const value = await handle(structuredClone(message.input), ctx);
+        reply({ type: 'done', id, ok: true, value: value === undefined ? null : value });
+    }
+    catch (err) {
+        if (err instanceof HttpError) {
+            reply({ type: 'done', id, ok: true, value: err.body, status: err.status });
+            return;
+        }
+        const e = err instanceof Error ? err : new Error(String(err));
+        reply({
+            type: 'done',
+            id,
+            ok: false,
+            fault: `threw ${e.name}: ${e.message.split('\n')[0]}`,
+            stderr: e.stack,
+        });
+    }
+}
+//# sourceMappingURL=worker.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/gym",
-    "version": "1.1.40",
+    "version": "1.1.42",
     "description": "Simulated API environments for agent training and evaluation, powered by OpenAPI and model-written generators.",
     "keywords": [
         "openapi",
@@ -46,9 +46,11 @@
     },
     "dependencies": {
         "@apidevtools/swagger-parser": "^12.0.0",
+        "@zenera/cli": "^1.1.42",
+        "@zenera/neo": "^1.1.42",
+        "@zenera/rag": "^1.1.42",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
-        "@zenera/cli": "^1.1.40",
-        "@zenera/neo": "^1.1.40"
+        "randexp": "^0.5.3"
     }
 }

package/dist/envelope.d.ts

@@ -1,13 +0,0 @@
-export interface GeneratorInput {
-    operationId: string;
-    method: string;
-    /** the template, not the resolved path — `/users/{user_id}` */
-    path: string;
-    pathParams: Record<string, unknown>;
-    query: Record<string, unknown>;
-    headers: Record<string, string>;
-    body: unknown;
-    /** seeds `random` and `Faker` inside the generator */
-    seed: number;
-}
-//# sourceMappingURL=envelope.d.ts.map

package/dist/envelope.js

@@ -1,9 +0,0 @@
-// ---------------------------------------------------------------------------
-// What a generator is handed
-//
-// One shape, written by the server for a real request and by the build loop for
-// a synthetic probe. That they are the same shape is the whole reason a
-// generator that satisfies its probes also satisfies traffic.
-// ---------------------------------------------------------------------------
-export {};
-//# sourceMappingURL=envelope.js.map

package/dist/image.d.ts

@@ -1,25 +0,0 @@
-import { type Runner } from '@zenera/neo';
-/**
- * Lower bounds rather than exact pins: the tag is a function of this list, so
- * an edit here yields a new image and a new container either way, and pinning a
- * patch release would only mean a rebuild every time one is published.
- */
-export declare const REQUIREMENTS: readonly ["Faker>=37", "exrex>=0.11", "jsonschema>=4.23", "python-dateutil>=2.9"];
-/** What the generator may import. Quoted verbatim in the prompt. */
-export declare const AVAILABLE: readonly ["faker", "exrex", "jsonschema", "dateutil"];
-export declare const BASE_IMAGE = "docker.io/library/python:3.14-slim-bookworm";
-export declare function imageTag(base?: string): string;
-export interface ImageOptions {
-    /** where the empty build context is created */
-    root: string;
-    base?: string;
-    engine?: string;
-    exec?: Runner;
-    onBuild?: (tag: string) => void;
-}
-/**
- * The tag to run, built if it is not there yet. Returns without touching podman
- * when the image already exists, which is every start after the first.
- */
-export declare function ensureImage(opts: ImageOptions): Promise<string>;
-//# sourceMappingURL=image.d.ts.map

package/dist/image.js

@@ -1,81 +0,0 @@
-import { createHash } from 'node:crypto';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { DEFAULT_SANDBOX_IMAGE, runProcess } from '@zenera/neo';
-// ---------------------------------------------------------------------------
-// The image
-//
-// The generators are Python, and Python that has to invent a plausible name out
-// of `random.choice` writes output that looks like test data because it is. So
-// the container gets real libraries.
-//
-// They cannot be installed into the *running* box. `containerName()` in
-// @zenera/neo hashes the image and the network, so "start online, install, then
-// switch to `network: none`" resolves to two different containers and the
-// install goes with the first one. Baking them into an image instead is one
-// build, cached by podman's own layers, and leaves the serving container
-// offline — which is the property that matters, because the code it runs was
-// written by a model.
-// ---------------------------------------------------------------------------
-/**
- * Lower bounds rather than exact pins: the tag is a function of this list, so
- * an edit here yields a new image and a new container either way, and pinning a
- * patch release would only mean a rebuild every time one is published.
- */
-export const REQUIREMENTS = [
-    'Faker>=37',
-    'exrex>=0.11',
-    'jsonschema>=4.23',
-    'python-dateutil>=2.9',
-];
-/** What the generator may import. Quoted verbatim in the prompt. */
-export const AVAILABLE = ['faker', 'exrex', 'jsonschema', 'dateutil'];
-export const BASE_IMAGE = DEFAULT_SANDBOX_IMAGE;
-export function imageTag(base = BASE_IMAGE) {
-    const digest = createHash('sha256')
-        .update(JSON.stringify([base, [...REQUIREMENTS].sort()]))
-        .digest('hex')
-        .slice(0, 12);
-    return `localhost/zenera-gym:${digest}`;
-}
-function containerfile(base) {
-    return [
-        `FROM ${base}`,
-        `RUN pip install --no-cache-dir --disable-pip-version-check ${REQUIREMENTS.join(' ')}`,
-        '',
-    ].join('\n');
-}
-/**
- * The tag to run, built if it is not there yet. Returns without touching podman
- * when the image already exists, which is every start after the first.
- */
-export async function ensureImage(opts) {
-    const base = opts.base ?? BASE_IMAGE;
-    const tag = imageTag(base);
-    const engine = opts.engine ?? 'podman';
-    const run = opts.exec ?? runProcess;
-    const exists = await run(engine, ['image', 'exists', tag], { timeoutMs: 60_000 });
-    if (exists.code === 0) {
-        return tag;
-    }
-    opts.onBuild?.(tag);
-    // An empty directory, because there is nothing to COPY: handing podman the
-    // working directory instead would tar up whatever happened to be in it.
-    const context = join(opts.root, 'build');
-    mkdirSync(context, { recursive: true });
-    // A real file rather than `--file -`: a spawned child's stdin is a
-    // socketpair, and a socket cannot be reopened through /dev/stdin, so the
-    // engine fails with ENXIO. It sits beside the context, not inside it, so
-    // the context stays empty.
-    const file = join(opts.root, 'Containerfile');
-    writeFileSync(file, containerfile(base));
-    const built = await run(engine, ['build', '--tag', tag, '--file', file, context], {
-        timeoutMs: 900_000,
-        maxBytes: 256 * 1024,
-    });
-    if (built.code !== 0) {
-        throw new Error(`could not build ${tag}: ${(built.stderr.trim() || built.stdout.trim()).split('\n').slice(-3).join(' ')}`);
-    }
-    return tag;
-}
-//# sourceMappingURL=image.js.map