if svm.Completed() {
			handler.ServeHTTP(w, req)
			return
		}
		ctx := req.Context()
		requestInfo, found := request.RequestInfoFrom(ctx)
		if !found {
			responsewriters.InternalError(w, req, errors.New("no RequestInfo found in the context"))
			return
		}
		// Allow non-resource requests
		if !requestInfo.IsResourceRequest {
			handler.ServeHTTP(w, req)
			return
		}

    auto func_op = llvm::dyn_cast<func::FuncOp>(
        *module_op->getBodyRegion().getOps().begin());
    if (!func_op) {
      return absl::InternalError("Input MLIR must have only 1 func");
    }
    if (arguments.size() != func_op.getNumArguments()) {
      return absl::InternalError("Input argument has wrong size");
    }

    // Convert input xla::Literal arguments to constants, this allows using

			w.Header().Set("Connection", "close")
		}
		ctx := req.Context()
		requestInfo, found := genericapirequest.RequestInfoFrom(ctx)
		if !found {
			responsewriters.InternalError(w, req, errors.New("no RequestInfo found in the context"))
			return
		}

		gv := schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}

  // fails to provide a valid file system.
  absl::Status GetFileSystemForFile(const std::string& fname,
                                    tsl::FileSystem** result) override {
    return absl::InternalError("Broken file system");
  }

 private:
  void GetLocalTempDirectories(std::vector<tsl::string>* list) override {
    list->push_back("/tmp");
  }
};

  // that requires compilation from HLO to executable.
  if (device_type != DEVICE_CPU && stream == nullptr &&
      !is_tfrt_tpu_supported_stage(stage)) {
    return absl::InternalError(
        "GetCompilerIr with requested stage is not supported on this device.");
  }
  return absl::OkStatus();
}

absl::StatusOr<std::vector<XlaCompiler::Argument>> PrepareXlaCompilerArgs(

            calibration_saved_model_dir, signature_keys_, tags_,
            /*force_graph_mode_calibration=*/true,
            representative_dataset_file_map) == std::nullopt) {
      return absl::InternalError(
          "CalibrationComponent error: Failed to run calibration.");
    }
  }

  if (absl::Status status = AddCalibrationStatistics(
          module_op, calibration_data_dir, config.calibration_options(),

import org.gradle.api.logging.LoggingManager
import org.gradle.api.resources.ResourceHandler
import org.gradle.api.tasks.WorkResult
import org.gradle.internal.deprecation.DeprecationLogger
import org.gradle.kotlin.dsl.support.internalError
import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.kotlin.dsl.support.unsafeLazy
import org.gradle.process.ExecResult
import org.gradle.process.ExecSpec
import org.gradle.process.JavaExecSpec

    if (num_submodules > 1) {
      return mlir::WalkResult::interrupt();
    }

    return mlir::WalkResult::advance();
  });

  if (num_submodules > 1) {
    auto num_submodules_error = absl::InternalError(
        "V1 Compat Bridge has more than one submodule. Erroring out.");
    TF_RETURN_IF_ERROR(RecordStatusIfError(
        /*error_prefix=*/"Bridge has more than one submodule:",

  for (int i = 0; i < ps.parameters_size(); ++i) {
    const xla::ShapeProto& shape = ps.parameters(i);
    if (shape.element_type() == xla::TUPLE) {
      // ShapeInfo cannot represent tuple args.
      return absl::InternalError(
          absl::StrCat("parameter ", i,
                       ": codegen requires XLA parameters to "
                       "be non-tuples."));
    }

		case cel.ErrorTypeInvalid:
			return field.Invalid(fldPath, expression.GetExpression(), celErr.Detail)
		case cel.ErrorTypeInternal:
			return field.InternalError(fldPath, celErr)
		}
	}
	return field.InternalError(fldPath, fmt.Errorf("unsupported error type: %w", err))
}