wip v28

Author: geraldarthurdavis

.gitignore

@@ -91,3 +91,4 @@ uapi/tailwind.config.js
 .tmp/
 .vercel
 .env*.local
+.bitcode/pipeline-harness-runs/

packages/agent-generics/src/__tests__/ptrr-step-prompt-formatting.test.ts

@@ -0,0 +1,147 @@
+// @ts-nocheck
+import { z } from 'zod';
+import { Prompt } from '@bitcode/prompts/prompt';
+import { AgentExecution } from '../execution';
+import { factoryPlanStep } from '../steps/factories';
+import { factoryStitchUntilComplete } from '../substeps/factories';
+
+describe('PTRR step prompt formatting', () => {
+  it('formats registry-backed step prompts instead of rendering Prompt objects', async () => {
+    process.env.BITCODE_DEBUG_ONLY_FAILSAFES = 'prepare';
+    process.env.BITCODE_DEBUG_ONLY_GENERATIONS = 'reason';
+
+    const prompt = new Prompt();
+    prompt.set('objective', 'Use source-bound evidence only.' as any);
+    prompt.set('constraint', 'Do not invent repository facts.' as any);
+
+    const execution = new AgentExecution('agent:test') as any;
+    execution.store('agent', 'name', 'test-agent');
+
+    const systemPrompts: string[] = [];
+    Object.defineProperty(execution, 'llms', {
+      configurable: true,
+      value: {
+        getDefaultConfig: () => ({ maxTokens: 4000 }),
+        getDefaultLLM: () => async (input: any) => {
+          const systemPrompt = input.messages?.[0]?.content || '';
+          const promptBody = input.messages?.map((message: any) => message.content).join('\n') || '';
+          systemPrompts.push(systemPrompt);
+
+          return {
+            content: JSON.stringify({
+              analysis: 'The prompt was formatted.',
+              steps: ['read prompt parts'],
+              conclusion: 'Continue.',
+              confidence: 1,
+            }),
+            usage: {},
+            metadata: {},
+          };
+        },
+      },
+    });
+
+    const plan = factoryPlanStep(z.object({ ok: z.boolean() }), { prompt });
+    try {
+      await plan({ read: 'Fit the deposited repository.' }, execution);
+
+      expect(systemPrompts.join('\n')).toContain('Use source-bound evidence only.');
+      expect(systemPrompts.join('\n')).not.toContain('[object Object]');
+    } finally {
+      delete process.env.BITCODE_DEBUG_ONLY_FAILSAFES;
+      delete process.env.BITCODE_DEBUG_ONLY_GENERATIONS;
+    }
+  });
+
+  it('renders function-backed Zod object schema keys in structured output prompts', async () => {
+    process.env.BITCODE_DEBUG_ONLY_FAILSAFES = 'prepare';
+    process.env.BITCODE_DEBUG_ONLY_GENERATIONS = 'structured_output';
+
+    const execution = new AgentExecution('agent:test') as any;
+    execution.store('agent', 'name', 'test-agent');
+
+    const prompts: string[] = [];
+    Object.defineProperty(execution, 'llms', {
+      configurable: true,
+      value: {
+        getDefaultConfig: () => ({ maxTokens: 4000 }),
+        getDefaultLLM: () => async (input: any) => {
+          const promptBody = input.messages?.map((message: any) => message.content).join('\n') || '';
+          prompts.push(promptBody);
+
+          return {
+            content: JSON.stringify({
+              read: { expressed_read: 'Fit the deposited repository.' },
+              written_asset_types: ['read-satisfaction-asset-pack'],
+            }),
+            usage: {},
+            metadata: {},
+          };
+        },
+      },
+    });
+
+    const plan = factoryPlanStep(
+      z.object({
+        read: z.object({ expressed_read: z.string() }),
+        written_asset_types: z.array(z.string()).default([]),
+      })
+    );
+    try {
+      await plan({ read: 'Fit the deposited repository.' }, execution);
+
+      const rendered = prompts.join('\n');
+      expect(rendered).toContain('"read"');
+      expect(rendered).toContain('"written_asset_types"');
+      expect(rendered).not.toContain('Output must match schema: {\n}');
+    } finally {
+      delete process.env.BITCODE_DEBUG_ONLY_FAILSAFES;
+      delete process.env.BITCODE_DEBUG_ONLY_GENERATIONS;
+    }
+  });
+
+  it('preserves original task context when stitch retries an incomplete partial output', async () => {
+    const execution = new AgentExecution('agent:test') as any;
+    const seenInputs: any[] = [];
+    const stitch = factoryStitchUntilComplete(
+      [
+        async (input: any) => {
+          seenInputs.push(input);
+          return {
+            output: {
+              read: {
+                expressed_read: input.context.read,
+              },
+            },
+          };
+        },
+      ],
+      z.object({
+        read: z.object({ expressed_read: z.string() }),
+      })
+    );
+
+    const result = await stitch(
+      {
+        read: 'Fit the deposited repository.',
+        sourceRevision: {
+          repositoryFullName: 'engineeredsoftware/ENGI',
+          branch: 'main',
+          commit: '07de275b3d97679321f1f596c16e48105d81d51b',
+        },
+        output: {},
+      },
+      execution
+    );
+
+    expect(seenInputs[0].context).toMatchObject({
+      read: 'Fit the deposited repository.',
+      sourceRevision: {
+        repositoryFullName: 'engineeredsoftware/ENGI',
+        branch: 'main',
+        commit: '07de275b3d97679321f1f596c16e48105d81d51b',
+      },
+    });
+    expect(result.finalOutput.read.expressed_read).toBe('Fit the deposited repository.');
+  });
+});

packages/agent-generics/src/steps/factories.ts

@@ -43,6 +43,19 @@ import { z } from 'zod';
 import { logStepTrace, logStepStart, logStepError } from '../diagnostics/instrumentation';
 import { createFailsafeGenerationSequence } from './failsafe-sequence';
 
+function formatStepPromptCarrier(prompt: any): any {
+  if (!prompt) return prompt;
+
+  const explicitPurpose = prompt.get?.('step:purpose');
+  if (explicitPurpose) return explicitPurpose;
+
+  if (typeof prompt.format === 'function') {
+    return prompt.format();
+  }
+
+  return prompt;
+}
+
 function normalizeToolUsage(usedTools: UsedTool[] | undefined): ToolUsageUpdate[] {
   return (usedTools || []).map((tool) => ({
     name: tool.tool,
@@ -148,7 +161,7 @@ export function factoryPlanStep<TInput, TOutput>(
     const started = Date.now();
     try { logStepStart(stepExec, 'plan'); } catch {}
     if (config?.prompt) {
-      const part = config.prompt.get?.('step:purpose') ?? config.prompt;
+      const part = formatStepPromptCarrier(config.prompt);
       stepExec.prompt.setSpecificExecution('specific_execution:step:purpose', part);
     }
     try {
@@ -234,7 +247,7 @@ export function factoryTryStep<TInput, TOutput>(
     const started = Date.now();
     try { logStepStart(stepExec, 'try'); } catch {}
     if (options?.prompt) {
-      stepExec.prompt.setSpecificExecution('specific_execution:step:purpose', options.prompt.get?.('step:purpose') || options.prompt);
+      stepExec.prompt.setSpecificExecution('specific_execution:step:purpose', formatStepPromptCarrier(options.prompt));
     }
     try {
       // Record usable tools
@@ -317,7 +330,7 @@ export function factoryRefineStep<TInput, TOutput>(
     const started = Date.now();
     try { logStepStart(stepExec, 'refine'); } catch {}
     if (options?.prompt) {
-      stepExec.prompt.setSpecificExecution('specific_execution:step:purpose', options.prompt.get?.('step:purpose') || options.prompt);
+      stepExec.prompt.setSpecificExecution('specific_execution:step:purpose', formatStepPromptCarrier(options.prompt));
     }
     try {
       // Record usable tools
@@ -404,7 +417,7 @@ export function factoryRetryStep<TInput, TOutput>(
     const started = Date.now();
     try { logStepStart(stepExec, 'retry'); } catch {}
     if (options?.prompt) {
-      stepExec.prompt.setSpecificExecution('specific_execution:step:purpose', options.prompt.get?.('step:purpose') || options.prompt);
+      stepExec.prompt.setSpecificExecution('specific_execution:step:purpose', formatStepPromptCarrier(options.prompt));
     }
     try {
       // Record usable tools

packages/agent-generics/src/substeps/factories.ts

@@ -615,6 +615,7 @@ export function factoryStitchUntilComplete<T>(
         ? (currentResult as any).output
         : currentResult;
       const stitchInput = {
+        context: buildStitchContext(input),
         partialOutput: minimalPartial,
         instruction: 'Continue and complete the previous output'
       } as any;
@@ -644,7 +645,12 @@ export function factoryStitchUntilComplete<T>(
       throw error;
     }
 
-    return { ...currentResult, finalOutput: (currentResult as any).output ?? currentResult };
+    const finalOutput = (currentResult as any).output ?? currentResult;
+    return {
+      context: buildStitchContext(input),
+      output: finalOutput,
+      finalOutput,
+    } as any;
   };
 }
 
@@ -702,7 +708,10 @@ export function factoryReason<T>(): Executor<T, T & { reasoning: Reasoning }> {
         const isSum = typedInput.chunkResults !== undefined;
 
         if (isStitch) {
-          return `Continue reasoning from this partial output:\n\n${JSON.stringify(typedInput.partialOutput, null, 2)}`;
+          const context = typedInput.context && Object.keys(typedInput.context).length
+            ? `\n\nOriginal task context:\n\n${JSON.stringify(typedInput.context, null, 2)}`
+            : '';
+          return `Continue reasoning from this partial output:\n\n${JSON.stringify(typedInput.partialOutput, null, 2)}${context}`;
         }
         if (isSum) {
           return `Reason about how to combine these chunk results:\n\n${JSON.stringify(typedInput.chunkResults, null, 2)}`;
@@ -780,9 +789,9 @@ export function factoryStructuredOutput<T, TSchema>(
 // Infer a minimal shape string from a Zod schema when description is missing
 function inferSchemaShape(s: z.ZodTypeAny): string {
   try {
-    const def: any = (s as any)._def;
-    if (def?.typeName === z.ZodFirstPartyTypeKind.ZodObject && def.shape) {
-      const entries = Object.entries(def.shape as Record<string, z.ZodTypeAny>);
+    const shape = getZodObjectShape(s);
+    if (shape) {
+      const entries = Object.entries(shape);
       const shapeLines = entries.map(([k, v]) => `  "${k}": ${inferField(v)}`);
       return `{
 ${shapeLines.join(',\n')}
@@ -798,38 +807,57 @@ function inferField(v: z.ZodTypeAny): string {
     case z.ZodFirstPartyTypeKind.ZodString: return 'string';
     case z.ZodFirstPartyTypeKind.ZodNumber: return 'number';
     case z.ZodFirstPartyTypeKind.ZodBoolean: return 'boolean';
+    case z.ZodFirstPartyTypeKind.ZodAny: return 'any';
+    case z.ZodFirstPartyTypeKind.ZodLiteral: return JSON.stringify((v as any)?._def?.value);
     case z.ZodFirstPartyTypeKind.ZodArray: {
       const inner = (v as any)?._def?.type;
       return `[ ${inner ? inferField(inner) : 'any'} ]`;
     }
-    case z.ZodFirstPartyTypeKind.ZodObject: return '{ ... }';
+    case z.ZodFirstPartyTypeKind.ZodObject: {
+      const shape = getZodObjectShape(v);
+      if (!shape) return '{ ... }';
+      const keys = Object.entries(shape).slice(0, 6);
+      return `{ ${keys.map(([key, value]) => `"${key}": ${inferField(value)}`).join(', ')}${Object.keys(shape).length > keys.length ? ', ...' : ''} }`;
+    }
     case z.ZodFirstPartyTypeKind.ZodRecord: return '{ [key: string]: any }';
-    case z.ZodFirstPartyTypeKind.ZodEnum: return 'enum';
+    case z.ZodFirstPartyTypeKind.ZodEnum: {
+      const values = (v as any)?._def?.values;
+      return Array.isArray(values) && values.length
+        ? values.map((value) => JSON.stringify(value)).join(' | ')
+        : 'enum';
+    }
+    case z.ZodFirstPartyTypeKind.ZodUnion: {
+      const options = (v as any)?._def?.options;
+      return Array.isArray(options) ? options.map(inferField).join(' | ') : 'any';
+    }
     case z.ZodFirstPartyTypeKind.ZodOptional: return `${inferField((v as any)?._def?.innerType)}?`;
+    case z.ZodFirstPartyTypeKind.ZodDefault: return `${inferField((v as any)?._def?.innerType)} = default`;
+    case z.ZodFirstPartyTypeKind.ZodNullable: return `${inferField((v as any)?._def?.innerType)} | null`;
     default: return 'any';
   }
 }
 
 function inferTopLevelKeys(s: z.ZodTypeAny): string[] {
   try {
-    const def: any = (s as any)._def;
-    if (def?.typeName === z.ZodFirstPartyTypeKind.ZodObject && def.shape) {
-      return Object.keys(def.shape as Record<string, z.ZodTypeAny>);
+    const shape = getZodObjectShape(s);
+    if (shape) {
+      return Object.keys(shape);
     }
   } catch { }
   return [];
 }
 
 function buildCoercedBySchema(s: z.ZodTypeAny): any {
   try {
-    const def: any = (s as any)._def;
-    if (def?.typeName === z.ZodFirstPartyTypeKind.ZodObject && def.shape) {
-      const shape = def.shape as Record<string, z.ZodTypeAny>;
+    const shape = getZodObjectShape(s);
+    if (shape) {
       const out: any = {};
       for (const [k, v] of Object.entries(shape)) {
         const t = (v as any)?._def?.typeName;
         const optional = t === z.ZodFirstPartyTypeKind.ZodOptional;
-        const inner = optional ? (v as any)?._def?.innerType : v;
+        const defaulted = t === z.ZodFirstPartyTypeKind.ZodDefault;
+        const nullable = t === z.ZodFirstPartyTypeKind.ZodNullable;
+        const inner = optional || defaulted || nullable ? (v as any)?._def?.innerType : v;
         const typeName = (inner as any)?._def?.typeName;
         if (optional) continue; // skip optional
         switch (typeName) {
@@ -853,6 +881,50 @@ function buildCoercedBySchema(s: z.ZodTypeAny): any {
   return {};
 }
 
+function getZodObjectShape(s: z.ZodTypeAny): Record<string, z.ZodTypeAny> | null {
+  try {
+    const def: any = (s as any)?._def;
+    if (def?.typeName !== z.ZodFirstPartyTypeKind.ZodObject) return null;
+    const rawShape = def.shape;
+    const shape = typeof rawShape === 'function' ? rawShape() : rawShape;
+    if (!shape || typeof shape !== 'object' || Array.isArray(shape)) return null;
+    return shape as Record<string, z.ZodTypeAny>;
+  } catch {
+    return null;
+  }
+}
+
+function buildStitchContext(input: unknown): Record<string, unknown> {
+  if (!input || typeof input !== 'object') return {};
+  const value = input as any;
+  const context: Record<string, unknown> = {};
+  const put = (key: string, candidate: unknown) => {
+    if (candidate !== undefined && candidate !== null && candidate !== '') {
+      context[key] = candidate;
+    }
+  };
+
+  if (value.context && typeof value.context === 'object' && !Array.isArray(value.context)) {
+    for (const [key, candidate] of Object.entries(value.context)) {
+      put(key, candidate);
+    }
+  }
+
+  put('read', value.read ?? value.expressedRead ?? value.definitionOfRead ?? value.context?.read);
+  put('definitionOfRead', value.definitionOfRead ?? value.context?.definitionOfRead);
+  put('repository', value.repository ?? value.sourceRevision?.repository ?? value.sourceRevision?.repositoryFullName ?? value.context?.repository);
+  put('sourceRevision', value.sourceRevision ?? value.context?.sourceRevision);
+  put('fitResult', value.fitResult ?? value.depositorySearchResult ?? value.context?.fitResult);
+  put('assetPackIntent', value.assetPackIntent ?? value.context?.assetPackIntent);
+  put('deliveryMechanism', value.deliveryMechanism ?? value.context?.deliveryMechanism);
+  if (Array.isArray(value.preparedContexts)) {
+    put('preparedContextCount', value.preparedContexts.length);
+    put('preparedContextSummaries', value.preparedContexts.slice(0, 3).map(summarize));
+  }
+
+  return context;
+}
+
 // ==================== TOOL SUBSTEP ====================
 
 // ==================== TOOL & VALIDATION SUBSTEPS ====================

packages/generic-llms/src/defaults.ts

@@ -31,7 +31,7 @@ export function resolveDefaultLLMModel(
       return 'claude-3-opus-20240229';
     case 'openai':
     default:
-      return 'gpt-4';
+      return 'gpt-4.1-mini';
   }
 }