@zenera/gym 1.1.40 → 1.1.41

package/dist/generate.d.ts

@@ -1,41 +1,46 @@
-import type { Model } from '@zenera/neo';
+import { type Model } from '@zenera/neo';
+import type { Bindings } from './bindings.ts';
 import type { Box } from './box.ts';
-import type { GeneratorInput } from './envelope.ts';
-import { type ExampleRequest } from './prompt.ts';
+import type { Catalog } from './catalog.ts';
+import { type Binding } from './runtime.ts';
+import { type Repair } from './prompt.ts';
 import { type Operation } from './spec.ts';
+import type { World } from './synth.ts';
 import { type Checks } from './validate.ts';
+/** Failed tests per build before giving up. */
+export declare const DEFAULT_ATTEMPTS = 5;
 export interface BuildOptions {
     model: Model;
     box: Box;
     checks: Checks;
-    /** how many times the model may be asked before giving up */
+    catalog: Catalog;
+    world: World;
+    /** where each type lives; a passing handler adds the ones it was first to use */
+    bindings: Bindings;
+    /** every operation being served, for siblings and list_operations */
+    operations: readonly Operation[];
+    /** the cached handler of another operation, if one has been written */
+    sourceOf: (operation: Operation) => Promise<string | undefined>;
     attempts?: number;
+    /** where HTML reports of agent runs go */
+    reportDir?: string;
     onAttempt?: (attempt: number, diagnostics: readonly string[], source: string, limit: number) => void | Promise<void>;
     signal?: AbortSignal;
 }
 export interface Built {
     source: string;
     attempts: number;
-}
-/**
- * Tries per generator. Each one carries the previous file and what was wrong
- * with it, so the later attempts are the informed ones — a model that has seen
- * its own traceback usually needs two or three goes at a fiddly schema, and the
- * whole loop costs nothing once the file is cached.
- */
-export declare const DEFAULT_ATTEMPTS = 5;
-export interface RegenerateOptions extends BuildOptions {
-    currentSource: string;
-    failingInput: GeneratorInput;
-    fault: string;
-    stderr?: string;
-    examples?: readonly ExampleRequest[];
+    report?: string;
+    /** where the handler stores each type it uses: part of its identity */
+    bindings: Record<string, Binding>;
 }
 export declare class BuildFailed extends Error {
     readonly operation: Operation;
     readonly diagnostics: readonly string[];
     /** the build report on disk, filled in by whoever was writing one */
     dump?: string;
+    /** the agent's HTML run report */
+    report?: string;
     constructor(operation: Operation, diagnostics: readonly string[]);
 }
 /**
@@ -43,15 +48,14 @@ export declare class BuildFailed extends Error {
  *
  * `fetch failed` is undici's word for a dozen different problems — a DNS
  * miss, a refused connection, a TLS error, a timeout — and which one it was is
- * only ever in `cause`. Reporting the top-level message alone turns every
- * network fault into the same useless sentence.
+ * only ever in `cause`.
  */
 export declare function reason(err: unknown): string;
-export declare function build(operation: Operation, opts: BuildOptions): Promise<Built>;
-export declare function regenerate(operation: Operation, opts: RegenerateOptions): Promise<Built>;
+/** Writes the handler for an operation, or repairs the one it has. */
+export declare function build(operation: Operation, opts: BuildOptions, repair?: Repair): Promise<Built>;
 /**
- * Models fence code even when told not to, and a stray ```python line is a
- * syntax error rather than a bad answer — not worth a round trip.
+ * Models fence code even when told not to, and a stray ```ts line is a syntax
+ * error rather than a bad answer — not worth a round trip.
  */
 export declare function unfence(text: string): string;
 //# sourceMappingURL=generate.d.ts.map