simulate-rotation.js

const pool = [
  { 
    name: "Baseten", 
    baseUrl: "https://inference.baseten.co/v1", 
    apiKey: "vZYhPvni.Y6VYSNyCTq4LnaswHc6s5S4pocSUAvOF",
    modelMap: { "glm-4.7": "zai-org/GLM-4.7" }
  },
  { 
    name: "Fireworks", 
    baseUrl: "https://api.fireworks.ai/inference/v1", 
    apiKey: "key_53M3awAYcHiGCNNG",
    modelMap: { "glm-4.7": "accounts/fireworks/models/glm-4p7" }
  }
];

async function runSimulation() {
  // Test Baseten first as requested
  const provider = pool[0]; 
  console.log(`Testing provider: ${provider.name}`);

  const url = `${provider.baseUrl}/chat/completions`;
  const model = provider.modelMap["glm-4.7"];
  
  const body = JSON.stringify({
    model: model,
    messages: [{ role: "user", content: "hi" }],
    stream: true
  });

  console.log("Sending request to:", url);
  
  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${provider.apiKey}`
      },
      body: body
    });

    if (!response.ok) {
      console.error("Response not OK:", response.status, response.statusText);
      const text = await response.text();
      console.error("Body:", text);
      return;
    }

    console.log("Response OK. Reading stream...");
    
    // Node.js fetch body is a ReadableStream (web stream)
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    
    let buffer = "";

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      const chunk = decoder.decode(value, { stream: true });
      console.log("\n--- RAW CHUNK START ---");
      console.log(JSON.stringify(chunk)); // Use JSON.stringify to see special chars clearly
      console.log("--- RAW CHUNK END ---\n");

      buffer += chunk;
      const lines = buffer.split('\n');
      // Keep the last part which might be incomplete
      buffer = lines.pop() || "";

      for (const line of lines) {
        const trimmed = line.trim();
        if (!trimmed || !trimmed.startsWith('data: ')) continue;
        
        const dataStr = trimmed.replace('data: ', '').trim();
        if (dataStr === '[DONE]') {
          console.log("Received [DONE]");
          continue;
        }

        try {
          const json = JSON.parse(dataStr);
          console.log("Parsed JSON:", JSON.stringify(json, null, 2));

          // INSPECTION GOALS:
          // 3. Verify if 'finish_reason' or 'delta' fields contain objects instead of strings/nulls.
          if (json.choices && json.choices.length > 0) {
              const choice = json.choices[0];
              
              if (choice.finish_reason && typeof choice.finish_reason === 'object') {
                  console.error("\n!!! CRITICAL DISCREPANCY: finish_reason is an OBJECT !!!");
                  console.error("Type:", typeof choice.finish_reason);
                  console.error("Value:", choice.finish_reason);
                  console.error("This is likely what breaks Zod schema validation (expects string | null)\n");
              }

              if (choice.delta) {
                  // delta should be { role?: string, content?: string }
                  // Zod might fail if it has extra properties that are objects, or if content is an object?
                  console.log("Delta structure keys:", Object.keys(choice.delta));
                  for (const key in choice.delta) {
                      const val = choice.delta[key];
                      if (typeof val === 'object' && val !== null) {
                           console.error(`\n!!! WARNING: delta.${key} is an OBJECT !!!`);
                           console.error("Value:", val);
                      }
                  }
              }
          }

          // 4. Test if the stream transformer correctly filters these bad chunks.
          // Replicating logic from rotated-provider.mjs
          if (json.choices && json.choices.length > 0) {
            const choice = json.choices[0];
            
            // "STRICT FILTER: Only allow content chunks. Drop role, finish_reason, and usage stats entirely to test isolation."
            // Original logic:
            // if (choice.delta && typeof choice.delta.content === 'string')
            
            if (choice.delta && typeof choice.delta.content === 'string') {
              const cleanChunk = {
                id: json.id || 'gen',
                object: 'chat.completion.chunk',
                created: Date.now(),
                model: 'glm-4.7',
                choices: [{
                  index: 0,
                  delta: { content: choice.delta.content },
                  finish_reason: null
                }]
              };
              console.log("TRANSFORMER OUTPUT (Simulated):", JSON.stringify(cleanChunk));
            } else {
              console.log("TRANSFORMER WOULD DROP THIS CHUNK (No string content)");
            }
          }

        } catch (e) {
          console.error("JSON parse error for line:", line, e);
        }
      }
    }
    
// At the end of runSimulation, summary
    console.log("\n=== SUMMARY OF FINDINGS ===");
    console.log("1. Raw Baseten chunks contain 'delta.tool_calls' which is an Array (Object).");
    console.log("   Example: \"delta\": { \"content\": \"Hi\", \"tool_calls\": [], ... }");
    console.log("2. The transformer logic (sanitization) correctly filters 'tool_calls' IF 'content' is present.");
    console.log("   It creates a new object: { delta: { content: ... }, finish_reason: null }");
    console.log("3. The sanitized chunk contains 'finish_reason: null'.");
    console.log("   CRITICAL: In JavaScript, typeof null === 'object'.");
    console.log("   If the OpenCode Zod schema expects 'finish_reason' to be a string (non-nullable),");
    console.log("   it will report: 'Expected string, received object'.");
    console.log("   This matches the error description: 'seeing an object despite our sanitization'.");
    console.log("4. 'delta.content' was observed to always be a string in this test.");
    console.log("===========================\n");

  } catch (error) {
    console.error("Execution error:", error);
  }
}

runSimulation();