feat: add support for lazy schema

Author: kedrzu

packages/core/src/agent/inferAgentInternal.ts

@@ -27,7 +27,7 @@ const SYSTEM_PROMPT = `You answer using programming language called AgentScript.
 - can't use regexes
 - can't use complex computation
 - can only use predefined functions and nothing else
-- to iterate over arrays always use \`map\` function
+- to iterate over arrays always use \`array.map()\` function
 - never assume array in non-empty
 - each function call or code block requires a comment briefly explaining the step
 

packages/core/src/modules/renderType.test.ts

@@ -679,3 +679,27 @@ describe('union', () => {
         expect(ctx.code).toEqual('');
     });
 });
+
+describe('lazy', () => {
+    test('basic object', () => {
+        const inner = s.object({ props: { name: s.string() } });
+        const schema = s.lazy(() => inner);
+        const ctx = createRenderContext();
+        const type = renderType({ schema, ctx });
+
+        expect(type).toEqual('{\n  name: string;\n}');
+        expect(ctx.code).toEqual('');
+    });
+
+    test('nullable object', () => {
+        const inner = s.object({ props: { name: s.string() } });
+        const schema = s.lazy({
+            of: () => inner,
+            nullable: true,
+        });
+        const ctx = createRenderContext();
+        const type = renderType({ schema: s.nullable(schema), ctx });
+
+        expect(type).toEqual('{\n  name: string;\n} | null');
+    });
+});

packages/core/src/modules/renderType.ts

@@ -97,6 +97,8 @@ function renderTypeInternal(
             return renderUnion(schema as s.UnionSchema, ctx, skipUndefined);
         case s.record:
             return renderRecord(schema as s.RecordSchema, ctx, skipUndefined);
+        case s.lazy:
+            return renderLazy(schema as s.LazySchema, ctx, skipUndefined);
         default:
             throw new Error(`Unsupported schema ${schema.type.name}`);
     }
@@ -158,6 +160,12 @@ function renderRecord(schema: s.RecordSchema, ctx: RenderContext, skipUndefined?
     return wrapType(schema, type, skipUndefined);
 }
 
+function renderLazy(schema: s.LazySchema, ctx: RenderContext, skipUndefined?: boolean) {
+    const unwrapped = unwrapLazy(schema);
+    const type = renderTypeInternal(unwrapped, ctx, skipUndefined);
+    return wrapType(unwrapped, type, skipUndefined);
+}
+
 function renderEnum(schema: s.EnumSchema, skipUndefined?: boolean) {
     const type = schema.values.map(option => `"${option}"`).join(' | ');
     return wrapType(schema, type, skipUndefined);
@@ -186,3 +194,16 @@ function findUniqueName(name: string, ctx: RenderContext) {
 
     return uniqueName;
 }
+
+function unwrapLazy(schema: s.LazySchema) {
+    const inner = schema.of();
+
+    const unwrapped: Partial<s.LazySchema> = schema;
+    delete unwrapped.of;
+
+    for (const key in inner) {
+        (unwrapped as Record<string, unknown>)[key] = inner[key as keyof typeof inner];
+    }
+
+    return unwrapped as s.Schema;
+}